Skunkware 5/Skunkware 5.iso/man/cat.1/bash.1

Text File | 1995-07-25 | 240KB | 3,961 lines

     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



     NNNNAAAAMMMMEEEE
          bash - GNU Bourne-Again SHell

     SSSSYYYYNNNNOOOOPPPPSSSSIIIISSSS
          bbbbaaaasssshhhh [options] [file]

     CCCCOOOOPPPPYYYYRRRRIIIIGGGGHHHHTTTT
          Bash is Copyright (C) 1989, 1991 by the Free Software
          Foundation, Inc.

     DDDDEEEESSSSCCCCRRRRIIIIPPPPTTTTIIIIOOOONNNN
          BBBBaaaasssshhhh is an sssshhhh-compatible command language interpreter that
          executes commands read from the standard input or from a
          file.  BBBBaaaasssshhhh also incorporates useful features from the _K_o_r_n
          and _C shells (kkkksssshhhh and ccccsssshhhh).

          BBBBaaaasssshhhh is ultimately intended to be a conformant
          implementation of the IEEE Posix Shell and Tools
          specification (IEEE Working Group 1003.2).

     OOOOPPPPTTTTIIIIOOOONNNNSSSS
          In addition to the single-character shell options documented
          in the description of the sssseeeetttt builtin command, bbbbaaaasssshhhh
          interprets the following flags when it is invoked:

          ----cccc _s_t_r_i_n_g If the ----cccc flag is present, then commands are read
                    from _s_t_r_i_n_g.  If there are arguments after the
                    _s_t_r_i_n_g, they are assigned to the positional
                    parameters, starting with $$$$0000.
          ----iiii        If the ----iiii flag is present, the shell is
                    _i_n_t_e_r_a_c_t_i_v_e.
          ----ssss        If the ----ssss flag is present, or if no arguments
                    remain after option processing, then commands are
                    read from the standard input.  This option allows
                    the positional parameters to be set when invoking
                    an interactive shell.
          ----         A single ---- signals the end of options and disables
                    further option processing.  Any arguments after
                    the ---- are treated as filenames and arguments.  An
                    argument of -------- is equivalent to an argument of ----.

          BBBBaaaasssshhhh also interprets a number of multi-character options.
          These options must appear on the command line before the
          single-character options to be recognized.

          ----nnnnoooorrrrcccc     Do not read and execute the personal
                    initialization file ~/._b_a_s_h_r_c if the shell is
                    interactive.  This option is on by default if the
                    shell is invoked as sssshhhh.
          ----nnnnoooopppprrrrooooffffiiiilllleeee
                    Do not read either the system-wide startup file
                    /_e_t_c/_p_r_o_f_i_l_e or any of the personal initialization



     Page 1                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                    files ~/._b_a_s_h__p_r_o_f_i_l_e, ~/._b_a_s_h__l_o_g_i_n, or
                    ~/._p_r_o_f_i_l_e.  By default, bbbbaaaasssshhhh normally reads these
                    files when it is invoked as a login shell (see
                    IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN below).
          ----rrrrccccffffiiiilllleeee _f_i_l_e
                    Execute commands from _f_i_l_e instead of the standard
                    personal initialization file ~/._b_a_s_h_r_c, if the
                    shell is interactive (see IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN below).
          ----vvvveeeerrrrssssiiiioooonnnn  Show the version number of this instance of bbbbaaaasssshhhh
                    when starting.
          ----qqqquuuuiiiieeeetttt    Do not be verbose when starting up (do not show
                    the shell version or any other information).  This
                    is the default.
          ----llllooooggggiiiinnnn    Make bbbbaaaasssshhhh act as if it had been invoked as a login
                    shell.
          ----nnnnoooobbbbrrrraaaacccceeeeeeeexxxxppppaaaannnnssssiiiioooonnnn
                    Do not perform curly brace expansion (see BBBBrrrraaaacccceeee
                    EEEExxxxppppaaaannnnssssiiiioooonnnn below).
          ----nnnnoooolllliiiinnnneeeeeeeeddddiiiittttiiiinnnngggg
                    Do not use the GNU _r_e_a_d_l_i_n_e library to read
                    command lines if interactive.
          ----ppppoooossssiiiixxxx    Change the behavior of bash where the default
                    operation differs from the Posix 1003.2 standard
                    to match the standard

     AAAARRRRGGGGUUUUMMMMEEEENNNNTTTTSSSS
          If arguments remain after option processing, and neither the
          ----cccc nor the ----ssss option has been supplied, the first argument
          is assumed to be the name of a file containing shell
          commands.  If bbbbaaaasssshhhh is invoked in this fashion, $$$$0000 is set to
          the name of the file, and the positional parameters are set
          to the remaining arguments.  BBBBaaaasssshhhh reads and executes
          commands from this file, then exits.  BBBBaaaasssshhhh''''ssss exit status is
          the exit status of the last command executed in the script.

     DDDDEEEEFFFFIIIINNNNIIIITTTTIIIIOOOONNNNSSSS
          bbbbllllaaaannnnkkkk
               A space or tab.
          wwwwoooorrrrdddd A sequence of characters considered as a single unit by
               the shell.  Also known as a ttttooookkkkeeeennnn.
          nnnnaaaammmmeeee A _w_o_r_d consisting only of alphanumeric characters and
               underscores, and beginning with an alphabetic character
               or an underscore.  Also referred to as an iiiiddddeeeennnnttttiiiiffffiiiieeeerrrr.
          mmmmeeeettttaaaacccchhhhaaaarrrraaaacccctttteeeerrrr
               A character that, when unquoted, separates words.  One
               of the following:
               ||||  &&&& ;;;; (((( )))) <<<< >>>> ssssppppaaaacccceeee ttttaaaabbbb
          ccccoooonnnnttttrrrroooollll ooooppppeeeerrrraaaattttoooorrrr
               A _t_o_k_e_n that performs a control function.  It is one of
               the following symbols:
               |||||||| &&&& &&&&&&&& ;;;; ;;;;;;;; (((( )))) |||| <<<<nnnneeeewwwwlllliiiinnnneeee>>>>




     Page 2                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



     RRRREEEESSSSEEEERRRRVVVVEEEEDDDD WWWWOOOORRRRDDDDSSSS
          _R_e_s_e_r_v_e_d _w_o_r_d_s are words that have a special meaning to the
          shell.  The following words are recognized as reserved when
          unquoted and either the first word of a simple command (see
          SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR below) or the third word of a ccccaaaasssseeee or ffffoooorrrr
          command:

          !!!! ccccaaaasssseeee  ddddoooo ddddoooonnnneeee eeeelllliiiiffff eeeellllsssseeee eeeessssaaaacccc ffffiiii ffffoooorrrr ffffuuuunnnnccccttttiiiioooonnnn iiiiffff iiiinnnn sssseeeelllleeeecccctttt
          tttthhhheeeennnn uuuunnnnttttiiiillll wwwwhhhhiiiilllleeee {{{{ }}}}

     SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR
        SSSSiiiimmmmpppplllleeee CCCCoooommmmmmmmaaaannnnddddssss
          A _s_i_m_p_l_e _c_o_m_m_a_n_d is a sequence of optional variable
          assignments followed by _b_l_a_n_k-separated words and
          redirections, and terminated by a _c_o_n_t_r_o_l _o_p_e_r_a_t_o_r.  The
          first word specifies the command to be executed.  The
          remaining words are passed as arguments to the invoked
          command.

          The return value of a _s_i_m_p_l_e _c_o_m_m_a_n_d is its exit status, or
          128+_n if the command is terminated by signal _n.

        PPPPiiiippppeeeelllliiiinnnneeeessss
          A _p_i_p_e_l_i_n_e is a sequence of one or more commands separated
          by the character ||||.  The format for a pipeline is:

               [ ! ] _c_o_m_m_a_n_d [ |||| _c_o_m_m_a_n_d_2 ... ]

          The standard output of _c_o_m_m_a_n_d is connected to the standard
          input of _c_o_m_m_a_n_d_2.  This connection is performed before any
          redirections specified by the command (see RRRREEEEDDDDIIIIRRRREEEECCCCTTTTIIIIOOOONNNN
          below).

          If the reserved word !!!! precedes a pipeline, the exit status
          of that pipeline is the logical NOT of the exit status of
          the last command.  Otherwise, the status of the pipeline is
          the exit status of the last command.  The shell waits for
          all commands in the pipeline to terminate before returning a
          value.

          Each command in a pipeline is executed as a separate process
          (i.e., in a subshell).

        LLLLiiiissssttttssss
          A _l_i_s_t is a sequence of one or more pipelines separated by
          one of the operators ;;;;, &&&&, &&&&&&&&, or ||||||||, and terminated by one
          of ;;;;, &&&&, or <<<<nnnneeeewwwwlllliiiinnnneeee>>>>.

          Of these list operators, &&&&&&&& and |||||||| have equal precedence,
          followed by ;;;; and &&&&,,,, which have equal precedence.

          If a command is terminated by the control operator &&&&, the



     Page 3                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          shell executes the command in the _b_a_c_k_g_r_o_u_n_d in a subshell.
          The shell does not wait for the command to finish, and the
          return status is 0.  Commands separated by a ;;;; are executed
          sequentially; the shell waits for each command to terminate
          in turn.  The return status is the exit status of the last
          command executed.

          The control operators &&&&&&&& and |||||||| denote AND lists and OR
          lists, respectively.  An AND list has the form

               _c_o_m_m_a_n_d &&&&&&&& _c_o_m_m_a_n_d_2

          _c_o_m_m_a_n_d_2 is executed if, and only if, _c_o_m_m_a_n_d returns an
          exit status of zero.

          An OR list has the form

               _c_o_m_m_a_n_d |||||||| _c_o_m_m_a_n_d_2

          _c_o_m_m_a_n_d_2 is executed if and only if _c_o_m_m_a_n_d returns a
          non-zero exit status.  The return status of AND and OR lists
          is the exit status of the last command executed in the list.

        CCCCoooommmmppppoooouuuunnnndddd CCCCoooommmmmmmmaaaannnnddddssss
          A _c_o_m_p_o_u_n_d _c_o_m_m_a_n_d is one of the following:

          (_l_i_s_t)
               _l_i_s_t is executed in a subshell.  Variable assignments
               and builtin commands that affect the shell's
               environment do not remain in effect after the command
               completes.  The return status is the exit status of
               _l_i_s_t.

          { _l_i_s_t; }
               _l_i_s_t is simply executed in the current shell
               environment.  This is known as a _g_r_o_u_p _c_o_m_m_a_n_d.  The
               return status is the exit status of _l_i_s_t.

          ffffoooorrrr _n_a_m_e [ iiiinnnn _w_o_r_d; ] ddddoooo _l_i_s_t ; ddddoooonnnneeee
               The list of words following iiiinnnn is expanded, generating
               a list of items.  The variable _n_a_m_e is set to each
               element of this list in turn, and _l_i_s_t is executed each
               time.  If the iiiinnnn _w_o_r_d is omitted, the ffffoooorrrr command
               executes _l_i_s_t once for each positional parameter that
               is set (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS below).

          sssseeeelllleeeecccctttt _n_a_m_e [ iiiinnnn _w_o_r_d; ] ddddoooo _l_i_s_t ; ddddoooonnnneeee
               The list of words following iiiinnnn is expanded, generating
               a list of items.  The set of expanded words is printed
               on the standard error, each preceded by a number.  If
               the iiiinnnn _w_o_r_d is omitted, the positional parameters are
               printed (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS below).  The PPPPSSSS3333 prompt is then



     Page 4                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               displayed and a line read from the standard input.  If
               the line consists of the number corresponding to one of
               the displayed words, then the value of _n_a_m_e is set to
               that word.  If the line is empty, the words and prompt
               are displayed again.  If EOF is read, the command
               completes.  Any other value read causes _n_a_m_e to be set
               to null.  The line read is saved in the variable RRRREEEEPPPPLLLLYYYY.
               The _l_i_s_t is executed after each selection until a bbbbrrrreeeeaaaakkkk
               or rrrreeeettttuuuurrrrnnnn command is executed.  The exit status of
               sssseeeelllleeeecccctttt is the exit status of the last command executed
               in _l_i_s_t, or zero if no commands were executed.

          ccccaaaasssseeee _w_o_r_d iiiinnnn [ _p_a_t_t_e_r_n [ |||| _p_a_t_t_e_r_n ] ... ) _l_i_s_t ;; ] ... eeeessssaaaacccc
               A ccccaaaasssseeee command first expands _w_o_r_d, and tries to match
               it against each _p_a_t_t_e_r_n in turn, using the same
               matching rules as for pathname expansion (see PPPPaaaatttthhhhnnnnaaaammmmeeee
               EEEExxxxppppaaaannnnssssiiiioooonnnn below).  When a match is found, the
               corresponding _l_i_s_t is executed.  After the first match,
               no subsequent matches are attempted.  The exit status
               is zero if no patterns are matches.  Otherwise, it is
               the exit status of the last command executed in _l_i_s_t.

          iiiiffff _l_i_s_t tttthhhheeeennnn _l_i_s_t [ eeeelllliiiiffff _l_i_s_t tttthhhheeeennnn _l_i_s_t ] ... [ eeeellllsssseeee _l_i_s_t ] ffffiiii
               The iiiiffff _l_i_s_t is executed.  If its exit status is zero,
               the tttthhhheeeennnn _l_i_s_t is executed.  Otherwise, each eeeelllliiiiffff _l_i_s_t
               is executed in turn, and if its exit status is zero,
               the corresponding tttthhhheeeennnn _l_i_s_t is executed and the command
               completes.  Otherwise, the eeeellllsssseeee _l_i_s_t is executed, if
               present.  The exit status is the exit status of the
               last command executed, or zero if no condition tested
               true.

          wwwwhhhhiiiilllleeee _l_i_s_t ddddoooo _l_i_s_t ddddoooonnnneeee
          uuuunnnnttttiiiillll _l_i_s_t ddddoooo _l_i_s_t ddddoooonnnneeee
               The wwwwhhhhiiiilllleeee command continuously executes the ddddoooo _l_i_s_t as
               long as the last command in _l_i_s_t returns an exit status
               of zero.  The uuuunnnnttttiiiillll command is identical to the wwwwhhhhiiiilllleeee
               command, except that the test is negated; the ddddoooo _l_i_s_t
               is executed as long as the last command in _l_i_s_t returns
               a non-zero exit status.  The exit status of the wwwwhhhhiiiilllleeee
               and uuuunnnnttttiiiillll commands is the exit status of the last ddddoooo
               _l_i_s_t command executed, or zero if none was executed.

          [ ffffuuuunnnnccccttttiiiioooonnnn ] _n_a_m_e () { _l_i_s_t; }
               This defines a function named _n_a_m_e.  The _b_o_d_y of the
               function is the _l_i_s_t of commands between { and }.  This
               list is executed whenever _n_a_m_e is specified as the name
               of a simple command.  The exit status of a function is
               the exit status of the last command executed in the
               body.  (See FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS below.)

     CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS



     PPPPaaaaggggeeee 5555                                           ((((pppprrrriiiinnnntttteeeedddd 7777////6666////99995555))))






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          In a non-interactive shell, or an interactive shell in which
          the ----oooo iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee----ccccoooommmmmmmmeeeennnnttttssss option to the sssseeeetttt builtin is
          enabled, a word beginning with #### causes that word and all
          remaining characters on that line to be ignored.  An
          interactive shell without the ----oooo iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee----ccccoooommmmmmmmeeeennnnttttssss option
          enabled does not allow comments.

     QQQQUUUUOOOOTTTTIIIINNNNGGGG
          _Q_u_o_t_i_n_g is used to remove the special meaning of certain
          characters or words to the shell.  Quoting can be used to
          disable special treatment for special characters, to prevent
          reserved words from being recognized as such, and to prevent
          parameter expansion.

          Each of the _m_e_t_a_c_h_a_r_a_c_t_e_r_s listed above under DDDDEEEEFFFFIIIINNNNIIIITTTTIIIIOOOONNNNSSSS
          has special meaning to the shell and must be quoted if they
          are to represent themselves.  There are three quoting
          mechanisms: the _e_s_c_a_p_e _c_h_a_r_a_c_t_e_r, single quotes, and double
          quotes.

          A non-quoted backslash (\\\\) is the _e_s_c_a_p_e _c_h_a_r_a_c_t_e_r.  It
          preserves the literal value of the next character that
          follows, with the exception of <newline>.  If a \\\\<newline>
          pair appears, and the backslash is not quoted, the
          \\\\<newline> is treated as a line continuation (that is, it is
          effectively ignored).

          Enclosing characters in single quotes preserves the literal
          value of each character within the quotes.  A single quote
          may not occur between single quotes, even when preceded by a
          backslash.

          Enclosing characters in double quotes preserves the literal
          value of all characters within the quotes, with the
          exception of $$$$, ````, and \\\\.  The characters $$$$ and ```` retain
          their special meaning within double quotes.  The backslash
          retains its special meaning only when followed by one of the
          following characters: $$$$, ````, """", \\\\, or <<<<nnnneeeewwwwlllliiiinnnneeee>>>>.  A double
          quote may be quoted within double quotes by preceding it
          with a backslash.

          The special parameters **** and @@@@ have special meaning when in
          double quotes (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS below).

     PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS
          A _p_a_r_a_m_e_t_e_r is an entity that stores values, somewhat like a
          variable in a conventional programming language.  It can be
          a _n_a_m_e, a number, or one of the special characters listed
          below under SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss.  For the shell's purposes, a
          _v_a_r_i_a_b_l_e is a parameter denoted by a _n_a_m_e.

          A parameter is set if it has been assigned a value.  The



     Page 6                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          null string is a valid value.  Once a variable is set, it
          may be unset only by using the uuuunnnnsssseeeetttt builtin command (see
          SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

          A _v_a_r_i_a_b_l_e may be assigned to by a statement of the form

               _n_a_m_e=[_v_a_l_u_e]

          If _v_a_l_u_e is not given, the variable is assigned the null
          string.  All _v_a_l_u_e_s undergo tilde expansion, parameter and
          variable expansion, command substitution, arithmetic
          expansion, and quote removal.  If the variable has its ----iiii
          attribute set (see ddddeeeeccccllllaaaarrrreeee below in SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS)
          then _v_a_l_u_e is subject to arithmetic expansion even if the
          $[...] syntax does not appear.  Word splitting is not
          performed, with the exception of """"$$$$@@@@"""" as explained below
          under SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss.  Pathname expansion is not
          performed.

        PPPPoooossssiiiittttiiiioooonnnnaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss
          A _p_o_s_i_t_i_o_n_a_l _p_a_r_a_m_e_t_e_r is a parameter denoted by one or more
          digits, other than the single digit 0.  Positional
          parameters are assigned from the shell's arguments when it
          is invoked, and may be reassigned using the sssseeeetttt builtin
          command.  Positional parameters may not be assigned to with
          assignment statements.  The positional parameters are
          temporarily replaced when a shell function is executed (see
          FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS below).

          When a positional parameter consisting of more than a single
          digit is expanded, it must be enclosed in braces (see
          EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below).

        SSSSppppeeeecccciiiiaaaallll PPPPaaaarrrraaaammmmeeeetttteeeerrrrssss
          The shell treats several parameters specially.  These
          parameters may only be referenced; assignment to them is not
          allowed.
          ****    Expands to the positional parameters, starting from
               one.  When the expansion occurs within double quotes,
               it expands to a single word with the value of each
               parameter separated by the first character of the IIIIFFFFSSSS
               special variable.  That is, ``$$$$****'' is equivalent to
               ``$$$$1111_c$$$$2222_c............'', where _c is the first character of the
               value of the IIIIFFFFSSSS variable.  If IIIIFFFFSSSS is null or unset,
               the parameters are separated by spaces.
          @@@@    Expands to the positional parameters, starting from
               one.  When the expansion occurs within double quotes,
               each parameter expands as a separate word.  That is, ``
               $$$$@@@@'' is equivalent to ``$$$$1111'' ``$$$$2222'' ...  When there are
               no positional parameters, ``$$$$@@@@'' and $$$$@@@@ expand to
               nothing (i.e., they are removed).
          ####    Expands to the number of positional parameters in



     Page 7                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               decimal.
          ????    Expands to the status of the most recently executed
               foreground pipeline.
          ----    Expands to the current option flags as specified upon
               invocation, by the sssseeeetttt builtin command, or those set by
               the shell itself (such as the ----iiii flag).
          $$$$    Expands to the process ID of the shell.  In a ()
               subshell, it expands to the process ID of the current
               shell, not the subshell.
          !!!!    Expands to the process ID of the most recently executed
               background (asynchronous) command.
          0000    Expands to the name of the shell or shell script.  This
               is set at shell initialization.  If bbbbaaaasssshhhh is invoked
               with a file of commands, $$$$0000 is set to the name of that
               file.  If bbbbaaaasssshhhh is started with the ----cccc option, then $$$$0000
               is set to the first argument after the string to be
               executed, if one is present.  Otherwise, it is set to
               the pathname used to invoke bbbbaaaasssshhhh, as given by argument
               zero.
          ____    Expands to the last argument to the previous command,
               after expansion.  Also set to the full pathname of each
               command executed and placed in the environment exported
               to that command.

        SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss
          The following variables are set by the shell:

          PPPPPPPPIIIIDDDD The process ID of the shell's parent.
          PPPPWWWWDDDD  The current working directory as set by the ccccdddd command.
          OOOOLLLLDDDDPPPPWWWWDDDD
               The previous working directory as set by the ccccdddd
               command.
          RRRREEEEPPPPLLLLYYYY
               Set to the line of input read by the rrrreeeeaaaadddd builtin
               command when no arguments are supplied.
          UUUUIIIIDDDD  Expands to the user ID of the current user, initialized
               at shell startup.
          EEEEUUUUIIIIDDDD Expands to the effective user ID of the current user,
               initialized at shell startup.
          BBBBAAAASSSSHHHH Expands to the full pathname used to invoke this
               instance of bbbbaaaasssshhhh.
          BBBBAAAASSSSHHHH____VVVVEEEERRRRSSSSIIIIOOOONNNN
               Expands to the version number of this instance of bbbbaaaasssshhhh.
          SSSSHHHHLLLLVVVVLLLL
               Incremented by one each time an instance of bbbbaaaasssshhhh is
               started.
          RRRRAAAANNNNDDDDOOOOMMMM
               Each time this parameter is referenced, a random
               integer is generated.  The sequence of random numbers
               may be initialized by assigning a value to RRRRAAAANNNNDDDDOOOOMMMM.  If
               RRRRAAAANNNNDDDDOOOOMMMM is unset, it loses its special properties, even
               if it is subsequently reset.



     Page 8                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          SSSSEEEECCCCOOOONNNNDDDDSSSS
               Each time this parameter is referenced, the number of
               seconds since shell invocation is returned.  If a value
               is assigned to SSSSEEEECCCCOOOONNNNDDDDSSSS, the value returned upon
               subsequent references is the number of seconds since
               the assignment plus the value assigned.  If SSSSEEEECCCCOOOONNNNDDDDSSSS is
               unset, it loses its special properties, even if it is
               subsequently reset.
          LLLLIIIINNNNEEEENNNNOOOO
               Each time this parameter is referenced, the shell
               substitutes a decimal number representing the current
               sequential line number (starting with 1) within a
               script or function.  When not in a script or function,
               the value substituted is not guaranteed to be
               meaningful.  When in a function, the value is not the
               number of the source line that the command appears on
               (that information has been lost by the time the
               function is executed), but is an approximation of the
               number of _s_i_m_p_l_e _c_o_m_m_a_n_d_s executed in the current
               function.  If LLLLIIIINNNNEEEENNNNOOOO is unset, it loses its special
               properties, even if it is subsequently reset.
          HHHHIIIISSSSTTTTCCCCMMMMDDDD
               The history number, or index in the history list, of
               the current command.  If HHHHIIIISSSSTTTTCCCCMMMMDDDD is unset, it loses its
               special properties, even if it is subsequently reset.
          OOOOPPPPTTTTAAAARRRRGGGG
               The value of the last option argument processed by the
               ggggeeeettttooooppppttttssss builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
               below).
          OOOOPPPPTTTTIIIINNNNDDDD
               The index of the next argument to be processed by the
               ggggeeeettttooooppppttttssss builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
               below).
          HHHHOOOOSSSSTTTTTTTTYYYYPPPPEEEE
               Automatically set to a string that uniquely describes
               the type of machine on which bbbbaaaasssshhhh is executing.  The
               default is system-dependent.
          OOOOSSSSTTTTYYYYPPPPEEEE
               Automatically set to a string that describes the
               operating system on which bbbbaaaasssshhhh is executing.  The
               default is system-dependent.

          The following variables are used by the shell.  In some
          cases, bbbbaaaasssshhhh assigns a default value to a variable; these
          cases are noted below.

          IIIIFFFFSSSS  The _I_n_t_e_r_n_a_l _F_i_e_l_d _S_e_p_a_r_a_t_o_r that is used for word
               splitting after expansion and to split lines into words
               with the rrrreeeeaaaadddd builtin command.  The default value is
               ``<space><tab><newline>''.
          PPPPAAAATTTTHHHH The search path for commands.  It is a colon-separated
               list of directories in which the shell looks for



     Page 9                                           (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               commands (see CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN below).  The default
               path is system-dependent, and is set by the
               administrator who installs bbbbaaaasssshhhh.  A common value is
               ``/usr/gnu/bin:/usr/local/bin:/usr/ucb:/bin:/usr/bin:.''.
          HHHHOOOOMMMMEEEE The home directory of the current user; the default
               argument for the ccccdddd builtin command.
          CCCCDDDDPPPPAAAATTTTHHHH
               The search path for the ccccdddd command.  This is a colon-
               separated list of directories in which the shell looks
               for destination directories specified by the ccccdddd
               command.  A sample value is ``.:~:/usr''.
          EEEENNNNVVVV  If this parameter is set when bbbbaaaasssshhhh is executing a shell
               script, its value is interpreted as a filename
               containing commands to initialize the shell, as in
               ._b_a_s_h_r_c.  The value of EEEENNNNVVVV is subjected to parameter
               expansion, command substitution, and arithmetic
               expansion before being interpreted as a pathname.  PPPPAAAATTTTHHHH
               is not used to search for the resultant pathname.
          MMMMAAAAIIIILLLL If this parameter is set to a filename and the MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH
               variable is not set, bbbbaaaasssshhhh informs the user of the
               arrival of mail in the specified file.
          MMMMAAAAIIIILLLLCCCCHHHHEEEECCCCKKKK
               Specifies how often (in seconds) bbbbaaaasssshhhh checks for mail.
               The default is 60 seconds.  When it is time to check
               for mail, the shell does so before prompting.  If this
               variable is unset, the shell disables mail checking.
          MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH
               A colon-separated list of pathnames to be checked for
               mail. The message to be printed may be specified by
               separating the pathname from the message with a `?'.
               $_ stands for the name of the current mailfile.
               Example:
               MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH='/usr/spool/mail/bfox?"You have
               mail":~/shell-mail?"$_ has mail!"'
               BBBBaaaasssshhhh supplies a default value for this variable, but
               the location of the user mail files that it uses is
               system dependent (e.g., /usr/spool/mail/$$$$UUUUSSSSEEEERRRR).
          MMMMAAAAIIIILLLL____WWWWAAAARRRRNNNNIIIINNNNGGGG
               If set, and a file that bbbbaaaasssshhhh is checking for mail has
               been accessed since the last time it was checked, the
               message ``The mail in _m_a_i_l_f_i_l_e has been read'' is
               printed.
          PPPPSSSS1111  The value of this parameter is expanded (see PPPPRRRROOOOMMMMPPPPTTTTIIIINNNNGGGG
               below) and used as the primary prompt string.  The
               default value is ``bbbbaaaasssshhhh\\\\$$$$ ''.
          PPPPSSSS2222  The value of this parameter is expanded and used as the
               secondary prompt string.  The default is ``>>>> ''.
          PPPPSSSS3333  The value of this parameter is used as the prompt for
               the _s_e_l_e_c_t command (see SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR above).
          PPPPSSSS4444  The value of this parameter is expanded and the value
               is printed before each command bbbbaaaasssshhhh displays during an
               execution trace.  The first character of PPPPSSSS4444 is



     Page 10                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               replicated multiple times, as necessary, to indicate
               multiple levels of indirection.  The default is ``++++ ''.
          HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE
               The number of commands to remember in the command
               history (see HHHHIIIISSSSTTTTOOOORRRRYYYY below).  The default value is 500.
          HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE
               The name of the file in which command history is saved.
               (See HHHHIIIISSSSTTTTOOOORRRRYYYY below.)  The default value is
               ~/._b_a_s_h__h_i_s_t_o_r_y.  If unset, the command history is not
               saved when an interactive shell exits.
          HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE
               The maximum number of lines contained in the history
               file.  When this variable is assigned a value, the
               history file is truncated, if necessary, to contain no
               more than that number of lines.  The default value is
               500.
          OOOOPPPPTTTTEEEERRRRRRRR
               If set to the value 1, bbbbaaaasssshhhh displays error messages
               generated by the ggggeeeettttooooppppttttssss builtin command (see SSSSHHHHEEEELLLLLLLL
               BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  OOOOPPPPTTTTEEEERRRRRRRR is initialized to 1
               each time the shell is invoked or a shell script is
               executed.
          PPPPRRRROOOOMMMMPPPPTTTT____CCCCOOOOMMMMMMMMAAAANNNNDDDD
               If set, the value is executed as a command prior to
               issuing each primary prompt.
          IIIIGGGGNNNNOOOORRRREEEEEEEEOOOOFFFF
               Controls the action of the shell on receipt of an EEEEOOOOFFFF
               character as the sole input.  If set, the value is the
               number of consecutive EEEEOOOOFFFF characters typed as the first
               characters on an input line before bbbbaaaasssshhhh exits.  If the
               variable exists but does not have a numeric value, or
               has no value, the default value is 10.  If it does not
               exist, EEEEOOOOFFFF signifies the end of input to the shell.
               This is only in effect for interactive shells.
          TTTTMMMMOOOOUUUUTTTT
               If set to a value greater than zero, the value is
               interpreted as the number of seconds to wait for input
               after issuing the primary prompt.  BBBBaaaasssshhhh terminates
               after waiting for that number of seconds if input does
               not arrive.
          FFFFCCCCEEEEDDDDIIIITTTT
               The default editor for the ffffcccc builtin command.
          FFFFIIIIGGGGNNNNOOOORRRREEEE
               A colon-separated list of suffixes to ignore when
               performing filename completion (see RRRREEEEAAAADDDDLLLLIIIINNNNEEEE below).  A
               filename whose suffix matches one of the entries in
               FFFFIIIIGGGGNNNNOOOORRRREEEE is excluded from the list of matched filenames.
               A sample value is ``.o:~''.
          IIIINNNNPPPPUUUUTTTTRRRRCCCC
               The filename for the readline startup file, overriding
               the default of ~/._i_n_p_u_t_r_c (see RRRREEEEAAAADDDDLLLLIIIINNNNEEEE below).
          nnnnoooottttiiiiffffyyyy



     Page 11                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               If set, bbbbaaaasssshhhh reports terminated background jobs
               immediately, rather than waiting until before printing
               the next primary prompt (see also the ----bbbb option to the
               sssseeeetttt builtin command).
          hhhhiiiissssttttoooorrrryyyy____ccccoooonnnnttttrrrroooollll
          HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL
               If set to a value of _i_g_n_o_r_e_s_p_a_c_e, lines which begin
               with a ssssppppaaaacccceeee character are not entered on the history
               list.  If set to a value of _i_g_n_o_r_e_d_u_p_s, lines matching
               the last history line are not entered.  A value of
               _i_g_n_o_r_e_b_o_t_h combines the two options.  If unset, or if
               set to any other value than those above, all lines read
               by the parser are saved on the history list.

          ccccoooommmmmmmmaaaannnndddd____oooorrrriiiieeeennnntttteeeedddd____hhhhiiiissssttttoooorrrryyyy
               If set, bbbbaaaasssshhhh attempts to save all lines of a
               multiple-line command in the same history entry.  This
               allows easy re-editing of multi-line commands.

          gggglllloooobbbb____ddddooootttt____ffffiiiilllleeeennnnaaaammmmeeeessss
               If set, bbbbaaaasssshhhh includes filenames beginning with a `.' in
               the results of pathname expansion.

          aaaalllllllloooowwww____nnnnuuuullllllll____gggglllloooobbbb____eeeexxxxppppaaaannnnssssiiiioooonnnn
               If set, bbbbaaaasssshhhh allows pathname patterns which match no
               files (see PPPPaaaatttthhhhnnnnaaaammmmeeee EEEExxxxppppaaaannnnssssiiiioooonnnn below) to expand to a
               null string, rather than themselves.

          hhhhiiiissssttttcccchhhhaaaarrrrssss
               The two or three characters which control history
               expansion and tokenization (see HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
               below).  The first character is the _h_i_s_t_o_r_y _e_x_p_a_n_s_i_o_n
               _c_h_a_r_a_c_t_e_r, that is, the character which signals the
               start of a history expansion, normally `!!!!'.  The second
               character is the _q_u_i_c_k _s_u_b_s_t_i_t_u_t_i_o_n character, which is
               used as shorthand for re-running the previous command
               entered, substituting one string for another in the
               command.  The default is `^^^^'.  The optional third
               character is the character which signifies that the
               remainder of the line is a comment, when found as the
               first character of a word, normally `####'.  The history
               comment character causes history substitution to be
               skipped for the remaining words on the line.  It does
               not necessarily cause the shell parser to treat the
               rest of the line as a comment.

          nnnnoooolllliiiinnnnkkkkssss
               If set, the shell does not follow symbolic links when
               executing commands that change the current working
               directory.  It uses the physical directory structure
               instead.  By default, bbbbaaaasssshhhh follows the logical chain of
               directories when performing commands which change the



     Page 12                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               current directory, such as ccccdddd.  See also the
               description of the ----PPPP option to the sssseeeetttt builtin ( SSSSHHHHEEEELLLLLLLL
               BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).
          hhhhoooossssttttnnnnaaaammmmeeee____ccccoooommmmpppplllleeeettttiiiioooonnnn____ffffiiiilllleeee
          HHHHOOOOSSSSTTTTFFFFIIIILLLLEEEE
               Contains the name of a file in the same format as
               /_e_t_c/_h_o_s_t_s that should be read when the shell needs to
               complete a hostname.  The file may be changed
               interactively; the next time hostname completion is
               attempted bbbbaaaasssshhhh adds the contents of the new file to the
               already existing database.

          nnnnoooocccclllloooobbbbbbbbeeeerrrr
               If set, bbbbaaaasssshhhh does not overwrite an existing file with
               the >>>>, >>>>&&&&, and <<<<>>>> redirection operators.  This variable
               may be overridden when creating output files by using
               the redirection operator >>>>|||| instead of >>>> (see also the
               ----CCCC option to the sssseeeetttt builtin command).

          aaaauuuuttttoooo____rrrreeeessssuuuummmmeeee
               This variable controls how the shell interacts with the
               user and job control.  If this variable is set, single
               word simple commands without redirections are treated
               as candidates for resumption of an existing stopped
               job.  There is no ambiguity allowed; if there is more
               than one job beginning with the string typed, the job
               most recently accessed is selected.  The _n_a_m_e of a
               stopped job, in this context, is the command line used
               to start it.  If set to the value _e_x_a_c_t, the string
               supplied must match the name of a stopped job exactly;
               if set to _s_u_b_s_t_r_i_n_g, the string supplied needs to match
               a substring of the name of a stopped job.  The
               _s_u_b_s_t_r_i_n_g value provides functionality analogous to the
               %%%%???? job id (see JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL below).  If set to any other
               value, the supplied string must be a prefix of a
               stopped job's name; this provides functionality
               analogous to the %%%% job id.

          nnnnoooo____eeeexxxxiiiitttt____oooonnnn____ffffaaaaiiiilllleeeedddd____eeeexxxxeeeecccc
               If this variable exists, a non-interactive shell will
               not exit if it cannot execute the file specified in the
               eeeexxxxeeeecccc builtin command.  An interactive shell does not
               exit if eeeexxxxeeeecccc fails.

          ccccddddaaaabbbblllleeee____vvvvaaaarrrrssss
               If this is set, an argument to the ccccdddd builtin command
               that is not a directory is assumed to be the name of a
               variable whose value is the directory to change to.

     EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
          Expansion is performed on the command line after it has been
          split into words.  There are seven kinds of expansion



     Page 13                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          performed: _b_r_a_c_e _e_x_p_a_n_s_i_o_n, _t_i_l_d_e _e_x_p_a_n_s_i_o_n, _p_a_r_a_m_e_t_e_r _a_n_d
          _v_a_r_i_a_b_l_e _e_x_p_a_n_s_i_o_n, _c_o_m_m_a_n_d _s_u_b_s_t_i_t_u_t_i_o_n, _a_r_i_t_h_m_e_t_i_c
          _e_x_p_a_n_s_i_o_n, _w_o_r_d _s_p_l_i_t_t_i_n_g, and _p_a_t_h_n_a_m_e _e_x_p_a_n_s_i_o_n.

          The order of expansions is: brace expansion, tilde
          expansion, parameter, variable, command, and arithmetic
          substitution (done in a left-to-right fashion), word
          splitting, and pathname expansion.

          On systems that can support it, there is an additional
          expansion available: _p_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n.

          Only brace expansion, word splitting, and pathname expansion
          can change the number of words of the expansion; other
          expansions expand a single word to a single word.  The
          single exception to this is the expansion of ``$$$$@@@@'' as
          explained above (see PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS).

        BBBBrrrraaaacccceeee EEEExxxxppppaaaannnnssssiiiioooonnnn
          _B_r_a_c_e _e_x_p_a_n_s_i_o_n is a mechanism by which arbitrary strings
          may be generated.  This mechanism is similar to _p_a_t_h_n_a_m_e
          _e_x_p_a_n_s_i_o_n, but the filenames generated need not exist.
          Patterns to be brace expanded take the form of an optional
          _p_r_e_a_m_b_l_e, followed by a series of comma-separated strings
          between a pair of braces, followed by an optional _p_o_s_t_a_m_b_l_e.
          The preamble is prepended to each string contained within
          the braces, and the postamble is then appended to each
          resulting string, expanding left to right.

          Brace expansions may be nested.  The results of each
          expanded string are not sorted; left to right order is
          preserved.  For example, a{{{{d,c,b}}}}e expands into `ade ace
          abe'.

          Brace expansion is performed before any other expansions,
          and any characters special to other expansions are preserved
          in the result.  It is strictly textual.  BBBBaaaasssshhhh does not apply
          any syntactic interpretation to the context of the expansion
          or the text between the braces.

          A correctly-formed brace expansion must contain unquoted
          opening and closing braces, and at least one unquoted comma.
          Any incorrectly formed brace expansion is left unchanged.

          This construct is typically used as shorthand when the
          common prefix of the strings to be generated is longer than
          in the above example:

               mkdir /usr/local/src/bash/{old,new,dist,bugs}
          or
               chown root /usr/{ucb/{ex,edit},lib/{ex?.?*,how_ex}}




     Page 14                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          Brace expansion introduces a slight incompatibility with
          traditional versions of sssshhhh, the Bourne shell.  sssshhhh does not
          treat opening or closing braces specially when they appear
          as part of a word, and preserves them in the output.  BBBBaaaasssshhhh
          removes braces from words as a consequence of brace
          expansion.  For example, a word entered to sssshhhh as _f_i_l_e{_1,_2}
          appears identically in the output.  The same word is output
          as _f_i_l_e_1 _f_i_l_e_2 after expansion by bbbbaaaasssshhhh.  If strict
          compatibility with sssshhhh is desired, start bbbbaaaasssshhhh with the
          ----nnnnoooobbbbrrrraaaacccceeeeeeeexxxxppppaaaannnnssssiiiioooonnnn flag (see OOOOPPPPTTTTIIIIOOOONNNNSSSS above) or disable brace
          expansion with the ++++oooo bbbbrrrraaaacccceeeeeeeexxxxppppaaaannnndddd option to the sssseeeetttt command
          (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

        TTTTiiiillllddddeeee EEEExxxxppppaaaannnnssssiiiioooonnnn
          If a word begins with a tilde character (`~~~~'), all of the
          characters preceding the first slash (or all characters, if
          there is no slash) are treated as a possible _l_o_g_i_n _n_a_m_e. If
          this _l_o_g_i_n _n_a_m_e is the null string, the tilde is replaced
          with the value of the parameter HHHHOOOOMMMMEEEE.  If HHHHOOOOMMMMEEEE is unset, the
          home directory of the user executing the shell is
          substituted instead.

          If a `+' follows the tilde, the value of PPPPWWWWDDDD replaces the
          tilde and `+'.  If a `-' follows, the value of OOOOLLLLDDDDPPPPWWWWDDDD is
          substituted.  If the value following the tilde is a valid
          _l_o_g_i_n _n_a_m_e, the tilde and _l_o_g_i_n _n_a_m_e are replaced with the
          home directory associated with that name.  If the name is
          invalid, or the tilde expansion fails, the word is
          unchanged.

          Each variable assignment is checked for unquoted instances
          of tildes following a :::: or ====.  In these cases, tilde
          substitution is also performed.  Consequently, one may use
          pathnames with tildes in assignments to PPPPAAAATTTTHHHH, MMMMAAAAIIIILLLLPPPPAAAATTTTHHHH, and
          CCCCDDDDPPPPAAAATTTTHHHH, and the shell assigns the expanded value.

        PPPPaaaarrrraaaammmmeeeetttteeeerrrr EEEExxxxppppaaaannnnssssiiiioooonnnn
          The `$$$$' character introduces parameter expansion, command
          substitution, or arithmetic expansion.  The parameter name
          or symbol to be expanded may be enclosed in braces, which
          are optional but serve to protect the variable to be
          expanded from characters immediately following it which
          could be interpreted as part of the name.

          ${_p_a_r_a_m_e_t_e_r}
               The value of _p_a_r_a_m_e_t_e_r is substituted.  The braces are
               required when _p_a_r_a_m_e_t_e_r is a positional parameter with
               more than one digit, or when _p_a_r_a_m_e_t_e_r is followed by a
               character which is not to be interpreted as part of its
               name.

          In each of the cases below, _w_o_r_d is subject to tilde



     Page 15                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          expansion, parameter expansion, command substitution, and
          arithmetic expansion.  BBBBaaaasssshhhh tests for a parameter that is
          unset or null; omitting the colon results in a test only for
          a parameter that is unset.

          ${_p_a_r_a_m_e_t_e_r::::----_w_o_r_d}
               UUUUsssseeee DDDDeeeeffffaaaauuuulllltttt VVVVaaaalllluuuueeeessss.  If _p_a_r_a_m_e_t_e_r is unset or null, the
               expansion of _w_o_r_d is substituted.  Otherwise, the value
               of _p_a_r_a_m_e_t_e_r is substituted.
          ${_p_a_r_a_m_e_t_e_r::::====_w_o_r_d}
               AAAAssssssssiiiiggggnnnn DDDDeeeeffffaaaauuuulllltttt VVVVaaaalllluuuueeeessss.  If _p_a_r_a_m_e_t_e_r is unset or null,
               the expansion of _w_o_r_d is assigned to _p_a_r_a_m_e_t_e_r.  The
               value of _p_a_r_a_m_e_t_e_r is then substituted.  Positional
               parameters and special parameters may not be assigned
               to in this way.
          ${_p_a_r_a_m_e_t_e_r::::????_w_o_r_d}
               DDDDiiiissssppppllllaaaayyyy EEEErrrrrrrroooorrrr iiiiffff NNNNuuuullllllll oooorrrr UUUUnnnnsssseeeetttt.  If _p_a_r_a_m_e_t_e_r is null
               or unset, the expansion of _w_o_r_d (or a message to that
               effect if _w_o_r_d is not present) is written to the
               standard error and the shell, if it is not interactive,
               exits.  Otherwise, the value of _p_a_r_a_m_e_t_e_r is
               substituted.
          ${_p_a_r_a_m_e_t_e_r::::++++_w_o_r_d}
               UUUUsssseeee AAAAlllltttteeeerrrrnnnnaaaatttteeee VVVVaaaalllluuuueeee.  If _p_a_r_a_m_e_t_e_r is null or unset,
               nothing is substituted, otherwise the expansion of _w_o_r_d
               is substituted.
          ${####_p_a_r_a_m_e_t_e_r}
               The length in characters of the value of _p_a_r_a_m_e_t_e_r is
               substituted.  If _p_a_r_a_m_e_t_e_r is **** or @@@@, the length
               substituted is the length of **** expanded within double
               quotes.
          ${_p_a_r_a_m_e_t_e_r####_w_o_r_d}
          ${_p_a_r_a_m_e_t_e_r########_w_o_r_d}
               The _w_o_r_d is expanded to produce a pattern just as in
               pathname expansion.  If the pattern matches the
               beginning of the value of _p_a_r_a_m_e_t_e_r, then the expansion
               is the value of _p_a_r_a_m_e_t_e_r with the shortest matching
               pattern deleted (the ``####'' case) or the longest
               matching pattern deleted (the ``########'' case).

          ${_p_a_r_a_m_e_t_e_r%%%%_w_o_r_d}
          ${_p_a_r_a_m_e_t_e_r%%%%%%%%_w_o_r_d}
               The _w_o_r_d is expanded to produce a pattern just as in
               pathname expansion.  If the pattern matches a trailing
               portion of the value of _p_a_r_a_m_e_t_e_r, then the expansion
               is the value of _p_a_r_a_m_e_t_e_r with the shortest matching
               pattern deleted (the ``%%%%'' case) or the longest
               matching pattern deleted (the ``%%%%%%%%'' case).

        CCCCoooommmmmmmmaaaannnndddd SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn
          _C_o_m_m_a_n_d _s_u_b_s_t_i_t_u_t_i_o_n allows the output of a command to
          replace the command name.  There are two forms:



     Page 16                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               $$$$((((_c_o_m_m_a_n_d))))
          or
               ````_c_o_m_m_a_n_d````

          BBBBaaaasssshhhh performs the expansion by executing _c_o_m_m_a_n_d and
          replacing the command substitution with the standard output
          of the command, with any trailing newlines deleted.

          When the old-style backquote form of substitution is used,
          backslash retains its literal meaning except when followed
          by $$$$, ````, or \\\\.  When using the $(_c_o_m_m_a_n_d) form, all
          characters between the parentheses make up the command; none
          are treated specially.

          Command substitutions may be nested.  To nest when using the
          old form, escape the inner backquotes with backslashes.

          If the substitution appears within double quotes, word
          splitting and pathname expansion are not performed on the
          results.

        AAAArrrriiiitttthhhhmmmmeeeettttiiiicccc EEEExxxxppppaaaannnnssssiiiioooonnnn
          Arithmetic expansion allows the evaluation of an arithmetic
          expression and the substitution of the result.  There are
          two formats for arithmetic expansion:

               $$$$[[[[_e_x_p_r_e_s_s_i_o_n]]]]

               $$$$((((((((_e_x_p_r_e_s_s_i_o_n))))))))

          The _e_x_p_r_e_s_s_i_o_n is treated as if it were within double
          quotes, but a double quote inside the braces or parentheses
          is not treated specially.  All tokens in the expression
          undergo parameter expansion, command substitution, and quote
          removal.  Arithmetic substitutions may be nested.

          The evaluation is performed according to the rules listed
          below under AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN.  If _e_x_p_r_e_s_s_i_o_n is
          invalid, bbbbaaaasssshhhh prints a message indicating failure and no
          substitution occurs.

        PPPPrrrroooocccceeeessssssss SSSSuuuubbbbssssttttiiiittttuuuuttttiiiioooonnnn
          _P_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n is supported on systems that support
          named pipes (_F_I_F_O_s) or the ////ddddeeeevvvv////ffffdddd method of naming open
          files.  It takes the form of <<<<((((_l_i_s_t)))) or >>>>((((_l_i_s_t)))).  The
          process _l_i_s_t is run with its input or output connected to a
          _F_I_F_O or some file in ////ddddeeeevvvv////ffffdddd.  The name of this file is
          passed as an argument to the current command as the result
          of the expansion.  If the >>>>((((_l_i_s_t)))) form is used, writing to
          the file will provide input for _l_i_s_t.  If the <<<<((((_l_i_s_t)))) form
          is used, the file passed as an argument should be read to
          obtain the output of _l_i_s_t.



     Page 17                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          On systems that support it, _p_r_o_c_e_s_s _s_u_b_s_t_i_t_u_t_i_o_n is
          performed simultaneously with _p_a_r_a_m_e_t_e_r _a_n_d _v_a_r_i_a_b_l_e
          _e_x_p_a_n_s_i_o_n, _c_o_m_m_a_n_d _s_u_b_s_t_i_t_u_t_i_o_n, and _a_r_i_t_h_m_e_t_i_c _e_x_p_a_n_s_i_o_n.

        WWWWoooorrrrdddd SSSSpppplllliiiittttttttiiiinnnngggg
          The shell scans the results of parameter expansion, command
          substitution, and arithmetic expansion that did not occur
          within double quotes for _w_o_r_d _s_p_l_i_t_t_i_n_g.

          The shell treats each character of IIIIFFFFSSSS as a delimiter, and
          splits the results of the other expansions into words on
          these characters.  If the value of IIIIFFFFSSSS is exactly
          <<<<ssssppppaaaacccceeee>>>><<<<ttttaaaabbbb>>>><<<<nnnneeeewwwwlllliiiinnnneeee>>>>, the default, then any sequence of IIIIFFFFSSSS
          characters serves to delimit words.  If IIIIFFFFSSSS has a value
          other than the default, then sequences of the whitespace
          characters ssssppppaaaacccceeee and ttttaaaabbbb are ignored at the beginning and
          end of the word, as long as the whitespace character is in
          the value of IIIIFFFFSSSS (an IIIIFFFFSSSS whitespace character).  Any
          character in IIIIFFFFSSSS that is not IIIIFFFFSSSS whitespace, along with any
          adjacent IIIIFFFFSSSS whitespace characters, delimits a field.  A
          sequence of IIIIFFFFSSSS whitespace characters is also treated as a
          delimiter.  If the value of IIIIFFFFSSSS is null, no word splitting
          occurs.  IIIIFFFFSSSS cannot be unset.

          Explicit null arguments ("""""""" or '''''''') are retained.  Implicit
          null arguments, resulting from the expansion of _p_a_r_a_m_e_t_e_r_s
          that have no values, are removed.

          Note that if no expansion occurs, no splitting is performed.

        PPPPaaaatttthhhhnnnnaaaammmmeeee EEEExxxxppppaaaannnnssssiiiioooonnnn
          After word splitting, unless the ----ffff option has been set,
          bbbbaaaasssshhhh scans each _w_o_r_d for the characters ****, ????, and [[[[.  If one
          of these characters appears, then the word is regarded as a
          _p_a_t_t_e_r_n, and replaced with an alphabetically sorted list of
          pathnames matching the pattern.  If no matching pathnames
          are found, and the shell variable aaaalllllllloooowwww____nnnnuuuullllllll____gggglllloooobbbb____eeeexxxxppppaaaannnnssssiiiioooonnnn
          is unset, the word is left unchanged.  If the variable is
          set, and no matches are found, the word is removed.  When a
          pattern is used for pathname generation, the character ````````....''''''''
          at the start of a name or immediately following a slash must
          be matched explicitly, unless the shell variable
          gggglllloooobbbb____ddddooootttt____ffffiiiilllleeeennnnaaaammmmeeeessss is set.  The slash character must always
          be matched explicitly.  In other cases, the ````````....'''''''' character
          is not treated specially.

          The special pattern characters have the following meanings:

          ****    Matches any string, including the null string.
          ????    Matches any single character.
          [[[[............]]]]
               Matches any one of the enclosed characters.  A pair of



     Page 18                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               characters separated by a minus sign denotes a _r_a_n_g_e;
               any character lexically between those two characters,
               inclusive, is matched.  If the first character
               following the [[[[ is a !!!! or a ^^^^ then any character not
               enclosed is matched.  A ---- or ]]]] may be matched by
               including it as the first or last character in the set.

        QQQQuuuuooootttteeee RRRReeeemmmmoooovvvvaaaallll
          After the preceding expansions, all unquoted occurrences of
          the characters \\\\, ````, and """" are removed.

     RRRREEEEDDDDIIIIRRRREEEECCCCTTTTIIIIOOOONNNN
          Before a command is executed, its input and output may be
          _r_e_d_i_r_e_c_t_e_d using a special notation interpreted by the
          shell.  Redirection may also be used to open and close files
          for the current shell execution environment.  The following
          redirection operators may precede or appear anywhere within
          a _s_i_m_p_l_e _c_o_m_m_a_n_d or may follow a _c_o_m_m_a_n_d.  Redirections are
          processed in the order they appear, from left to right.

          In the following descriptions, if the file descriptor number
          is omitted, and the first character of the redirection
          operator is <<<<, the redirection refers to the standard input
          (file descriptor 0).  If the first character of the
          redirection operator is >>>>, the redirection refers to the
          standard output (file descriptor 1).

          The word that follows the redirection operator in the
          following descriptions is subjected to brace expansion,
          tilde expansion, parameter expansion, command substitution,
          arithmetic expansion, quote removal, and pathname expansion.
          If it expands to more than one word, bbbbaaaasssshhhh reports an error.

          Note that the order of redirections is significant.  For
          example, the command

               ls >>>> dirlist 2>>>>&&&&1

          directs both standard output and standard error to the file
          _d_i_r_l_i_s_t, while the command

               ls 2>>>>&&&&1 >>>> dirlist

          directs only the standard output to file _d_i_r_l_i_s_t, because
          the standard error was duplicated as standard output before
          the standard output was redirected to _d_i_r_l_i_s_t.

        RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg IIIInnnnppppuuuutttt
          Redirection of input causes the file whose name results from
          the expansion of _w_o_r_d to be opened for reading on file
          descriptor _n, or the standard input (file descriptor 0) if _n
          is not specified.



     Page 19                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          The general format for redirecting input is:

               [_n]<<<<_w_o_r_d

        RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg OOOOuuuuttttppppuuuutttt
          Redirection of output causes the file whose name results
          from the expansion of _w_o_r_d to be opened for writing on file
          descriptor _n, or the standard output (file descriptor 1) if
          _n is not specified.  If the file does not exist it is
          created; if it does exist it is truncated to zero size.

          The general format for redirecting output is:

               [_n]>>>>_w_o_r_d

          If the redirection operator is >>>>||||, then the value of the ----CCCC
          option to the sssseeeetttt builtin command is not tested, and file
          creation is attempted.  (See also the description of
          nnnnoooocccclllloooobbbbbbbbeeeerrrr under SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss above.)

        AAAAppppppppeeeennnnddddiiiinnnngggg RRRReeeeddddiiiirrrreeeecccctttteeeedddd OOOOuuuuttttppppuuuutttt
          Redirection of output in this fashion causes the file whose
          name results from the expansion of _w_o_r_d to be opened for
          appending on file descriptor _n, or the standard output (file
          descriptor 1) if _n is not specified.  If the file does not
          exist it is created.

          The general format for appending output is:

               [_n]>>>>>>>>_w_o_r_d

        RRRReeeeddddiiiirrrreeeeccccttttiiiinnnngggg SSSSttttaaaannnnddddaaaarrrrdddd OOOOuuuuttttppppuuuutttt aaaannnndddd SSSSttttaaaannnnddddaaaarrrrdddd EEEErrrrrrrroooorrrr
          BBBBaaaasssshhhh allows both the standard output (file descriptor 1) and
          the standard error output (file descriptor 2) to be
          redirected to the file whose name is the expansion of _w_o_r_d
          with this construct.

          There are two formats for redirecting standard output and
          standard error:

               &&&&>>>>_w_o_r_d
          and
               >>>>&&&&_w_o_r_d

          Of the two forms, the first is preferred.  This is
          semantically equivalent to

               >>>>_w_o_r_d 2>>>>&&&&1

        HHHHeeeerrrreeee DDDDooooccccuuuummmmeeeennnnttttssss
          This type of redirection instructs the shell to read input
          from the current source until a line containing only _w_o_r_d



     Page 20                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          (with no trailing blanks) is seen.  All of the lines read up
          to that point are then used as the standard input for a
          command.

          The format of here-documents is as follows:

               <<<<<<<<[----]_w_o_r_d
                       _h_e_r_e-_d_o_c_u_m_e_n_t
               _d_e_l_i_m_i_t_e_r

          No parameter expansion, command substitution, pathname
          expansion, or arithmetic expansion is performed on _w_o_r_d.  If
          any characters in _w_o_r_d are quoted, the _d_e_l_i_m_i_t_e_r is the
          result of quote removal on _w_o_r_d, and the lines in the here-
          document are not expanded.  Otherwise, all lines of the
          here-document are subjected to parameter expansion, command
          substitution, and arithmetic expansion.  In the latter case,
          the pair \\\\<<<<nnnneeeewwwwlllliiiinnnneeee>>>> is ignored, and \\\\ must be used to quote
          the characters \\\\, $$$$, and ````.

          If the redirection operator is <<<<<<<<----, then all leading tab
          characters are stripped from input lines and the line
          containing _d_e_l_i_m_i_t_e_r.  This allows here-documents within
          shell scripts to be indented in a natural fashion.

        DDDDuuuupppplllliiiiccccaaaattttiiiinnnngggg FFFFiiiilllleeee DDDDeeeessssccccrrrriiiippppttttoooorrrrssss
          The redirection operator

               [_n]<<<<&&&&_w_o_r_d

          is used to duplicate input file descriptors.  If _w_o_r_d
          expands to one or more digits, the file descriptor denoted
          by _n is made to be a copy of that file descriptor.  If _w_o_r_d
          evaluates to ----, file descriptor _n is closed.  If _n is not
          specified, the standard input (file descriptor 0) is used.

          The operator

               [_n]>>>>&&&&_w_o_r_d

          is used similarly to duplicate output file descriptors.  If
          _n is not specified, the standard output (file descriptor 1)
          is used.  As a special case, if _n is omitted, and _w_o_r_d does
          not expand to one or more digits, the standard output and
          standard error are redirected as described previously.

        OOOOppppeeeennnniiiinnnngggg FFFFiiiilllleeee DDDDeeeessssccccrrrriiiippppttttoooorrrrssss ffffoooorrrr RRRReeeeaaaaddddiiiinnnngggg aaaannnndddd WWWWrrrriiiittttiiiinnnngggg
          The redirection operator

               [_n]<<<<>>>>_w_o_r_d

          causes the file whose name is the expansion of _w_o_r_d to be



     Page 21                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          opened for both reading and writing on file descriptor _n, or
          as the standard input and standard output if _n is not
          specified.  If the file does not exist, it is created.

     FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS
          A shell function, defined as described above under SSSSHHHHEEEELLLLLLLL
          GGGGRRRRAAAAMMMMMMMMAAAARRRR, stores a series of commands for later execution.
          Functions are executed in the context of the current shell;
          no new process is created to interpret them (contrast this
          with the execution of a shell script).  When a function is
          executed, the arguments to the function become the
          positional parameters during its execution.  The special
          parameter #### is updated to reflect the change.  Positional
          parameter 0 is unchanged.

          Variables local to the function may be declared with the
          llllooooccccaaaallll builtin command.  Ordinarily, variables and their
          values are shared between the function and its caller.

          If the builtin command rrrreeeettttuuuurrrrnnnn is executed in a function, the
          function completes and execution resumes with the next
          command after the function call.  When a function completes,
          the values of the positional parameters and the special
          parameter #### are restored to the values they had prior to
          function execution.

          Function names may be listed with the ----ffff option to the
          ddddeeeeccccllllaaaarrrreeee or ttttyyyyppppeeeesssseeeetttt builtin commands.  Functions may be
          exported so that subshells automatically have them defined
          with the ----ffff option to the eeeexxxxppppoooorrrrtttt builtin.

          Functions may be recursive.  No limit is imposed on the
          number of recursive calls.

     AAAALLLLIIIIAAAASSSSEEEESSSS
          The shell maintains a list of _a_l_i_a_s_e_s that may be set and
          unset with the aaaalllliiiiaaaassss and uuuunnnnaaaalllliiiiaaaassss builtin commands (see SSSSHHHHEEEELLLLLLLL
          BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  The first word of each command, if
          unquoted, is checked to see if it has an alias.  If so, that
          word is replaced by the text of the alias.  The alias name
          and the replacement text may contain any valid shell input,
          including the _m_e_t_a_c_h_a_r_a_c_t_e_r_s listed above, with the
          exception that the alias name may not contain =.  The first
          word of the replacement text is tested for aliases, but a
          word that is identical to an alias being expanded is not
          expanded a second time.  This means that one may alias llllssss to
          llllssss ----FFFF, for instance, and bbbbaaaasssshhhh does not try to recursively
          expand the replacement text.  If the last character of the
          alias value is a _b_l_a_n_k, then the next command word following
          the alias is also checked for alias expansion.

          Aliases are created and listed with the aaaalllliiiiaaaassss command, and



     Page 22                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          removed with the uuuunnnnaaaalllliiiiaaaassss command.

          There is no mechanism for using arguments in the replacement
          text, as in ccccsssshhhh.  If arguments are needed, a shell function
          should be used.

          Aliases are not expanded when the shell is not interactive.

          The rules concerning the definition and use of aliases are
          somewhat confusing.  BBBBaaaasssshhhh always reads at least one complete
          line of input before executing any of the commands on that
          line.  Aliases are expanded when a command is read, not when
          it is executed.  Therefore, an alias definition appearing on
          the same line as another command does not take effect until
          the next line of input is read.  This means that the
          commands following the alias definition on that line are not
          affected by the new alias.  This behavior is also an issue
          when functions are executed.  Aliases are expanded when the
          function definition is read, not when the function is
          executed, because a function definition is itself a compound
          command.  As a consequence, aliases defined in a function
          are not available until after that function is executed.  To
          be safe, always put alias definitions on a separate line,
          and do not use aaaalllliiiiaaaassss in compound commands.

          Note that for almost every purpose, aliases are superseded
          by shell functions.

     JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL
          _J_o_b _c_o_n_t_r_o_l refers to the ability to selectively stop
          (_s_u_s_p_e_n_d) the execution of processes and continue (_r_e_s_u_m_e)
          their execution at a later point.  A user typically employs
          this facility via an interactive interface supplied jointly
          by the system's terminal driver and bbbbaaaasssshhhh.

          The shell associates a _j_o_b with each pipeline.  It keeps a
          table of currently executing jobs, which may be listed with
          the jjjjoooobbbbssss command.  When bbbbaaaasssshhhh starts a job asynchronously (in
          the _b_a_c_k_g_r_o_u_n_d), it prints a line that looks like:

               [1] 25647

          indicating that this job is job number 1 and that the
          process ID of the last process in the pipeline associated
          with this job is 25647.  All of the processes in a single
          pipeline are members of the same job.  BBBBaaaasssshhhh uses the _j_o_b
          abstraction as the basis for job control.

          To facilitate the implementation of the user interface to
          job control, the system maintains the notion of a _c_u_r_r_e_n_t
          _t_e_r_m_i_n_a_l _p_r_o_c_e_s_s _g_r_o_u_p _I_D.  Members of this process group
          (processes whose process group ID is equal to the current



     Page 23                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          terminal process group ID) receive keyboard-generated
          signals such as SSSSIIIIGGGGIIIINNNNTTTT.  These processes are said to be in
          the _f_o_r_e_g_r_o_u_n_d.  _B_a_c_k_g_r_o_u_n_d processes are those whose
          process group ID differs from the terminal's; such processes
          are immune to keyboard-generated signals.  Only foreground
          processes are allowed to read from or write to the terminal.
          Background processes which attempt to read from (write to)
          the terminal are sent a SSSSIIIIGGGGTTTTTTTTIIIINNNN ((((SSSSIIIIGGGGTTTTTTTTOOOOUUUU)))) signal by the
          terminal driver, which, unless caught, suspends the process.

          If the operating system on which bbbbaaaasssshhhh is running supports
          job control, bbbbaaaasssshhhh allows you to use it.  Typing the _s_u_s_p_e_n_d
          character (typically ^^^^ZZZZ, Control-Z) while a process is
          running causes that process to be stopped and returns you to
          bbbbaaaasssshhhh.  Typing the _d_e_l_a_y_e_d _s_u_s_p_e_n_d character (typically ^^^^YYYY,
          Control-Y) causes the process to be stopped when it attempts
          to read input from the terminal, and control to be returned
          to bbbbaaaasssshhhh.  You may then manipulate the state of this job,
          using the bbbbgggg command to continue it in the background, the
          ffffgggg command to continue it in the foreground, or the kkkkiiiillllllll
          command to kill it.  A ^^^^ZZZZ takes effect immediately, and has
          the additional side effect of causing pending output and
          typeahead to be discarded.

          There are a number of ways to refer to a job in the shell.
          The character %%%% introduces a job name.  Job number _n may be
          referred to as %%%%nnnn.  A job may also be referred to using a
          prefix of the name used to start it, or using a substring
          that appears in its command line.  For example, %%%%cccceeee refers
          to a stopped cccceeee job.  If a prefix matches more than one job,
          bbbbaaaasssshhhh reports an error.  Using %%%%????cccceeee, on the other hand,
          refers to any job containing the string cccceeee in its command
          line.  If the substring matches more than one job, bbbbaaaasssshhhh
          reports an error.  The symbols %%%%%%%% and %%%%++++ refer to the
          shell's notion of the _c_u_r_r_e_n_t _j_o_b, which is the last job
          stopped while it was in the foreground.  The _p_r_e_v_i_o_u_s _j_o_b
          may be referenced using %%%%----.  In output pertaining to jobs
          (e.g., the output of the jjjjoooobbbbssss command), the current job is
          always flagged with a ++++, and the previous job with a ----.

          Simply naming a job can be used to bring it into the
          foreground: %%%%1111 is a synonym for ````````ffffgggg %%%%1111'''''''', bringing job 1
          from the background into the foreground.  Similarly, ````````%%%%1111
          &&&&'''''''' resumes job 1 in the background, equivalent to ````````bbbbgggg
          %%%%1111''''''''.

          The shell learns immediately whenever a job changes state.
          Normally, bbbbaaaasssshhhh waits until it is about to print a prompt
          before reporting changes in a job's status so as to not
          interrupt any other output.  If the ----bbbb option to the sssseeeetttt
          builtin command is set, bbbbaaaasssshhhh reports such changes
          immediately.  (See also the description of nnnnoooottttiiiiffffyyyy variable



     Page 24                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          under SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss above.)

          If you attempt to exit bbbbaaaasssshhhh while jobs are stopped, the
          shell prints a message warning you.  You may then use the
          jjjjoooobbbbssss command to inspect their status.  If you do this, or
          try to exit again immediately, you are not warned again, and
          the stopped jobs are terminated.

     SSSSIIIIGGGGNNNNAAAALLLLSSSS
          When bbbbaaaasssshhhh is interactive, it ignores SSSSIIIIGGGGTTTTEEEERRRRMMMM (so that kkkkiiiillllllll 0000
          does not kill an interactive shell), and SSSSIIIIGGGGIIIINNNNTTTT is caught
          and handled (so that the wwwwaaaaiiiitttt builtin is interruptible).  In
          all cases, bbbbaaaasssshhhh ignores SSSSIIIIGGGGQQQQUUUUIIIITTTT.  If job control is in
          effect, bbbbaaaasssshhhh ignores SSSSIIIIGGGGTTTTTTTTIIIINNNN, SSSSIIIIGGGGTTTTTTTTOOOOUUUU, and SSSSIIIIGGGGTTTTSSSSTTTTPPPP.

          Synchronous jobs started by bbbbaaaasssshhhh have signals set to the
          values inherited by the shell from its parent.  When job
          control is not in effect, background jobs (jobs started with
          &&&&) ignore SSSSIIIIGGGGIIIINNNNTTTT and SSSSIIIIGGGGQQQQUUUUIIIITTTT.  Commands run as a result of
          command substitution ignore the keyboard-generated job
          control signals SSSSIIIIGGGGTTTTTTTTIIIINNNN, SSSSIIIIGGGGTTTTTTTTOOOOUUUU, and SSSSIIIIGGGGTTTTSSSSTTTTPPPP.

     CCCCOOOOMMMMMMMMAAAANNNNDDDD EEEEXXXXEEEECCCCUUUUTTTTIIIIOOOONNNN
          After a command has been split into words, if it results in
          a simple command and an optional list of arguments, the
          following actions are taken.

          If the command name contains no slashes, the shell attempts
          to locate it.  If there exists a shell function by that
          name, that function is invoked as described above in
          FFFFUUUUNNNNCCCCTTTTIIIIOOOONNNNSSSS.  If the name does not match a function, the shell
          searches for it in the list of shell builtins.  If a match
          is found, that builtin is invoked.

          If the name is neither a shell function nor a builtin, and
          contains no slashes, bbbbaaaasssshhhh searches each element of the PPPPAAAATTTTHHHH
          for a directory containing an executable file by that name.
          If the search is unsuccessful, the shell prints an error
          message and returns a nonzero exit status.

          If the search is successful, or if the command name contains
          one or more slashes, the shell executes the named program.
          Argument 0 is set to the name given, and the remaining
          arguments to the command are set to the arguments given, if
          any.

          If this execution fails because the file is not in
          executable format, and the file is not a directory, it is
          assumed to be a _s_h_e_l_l _s_c_r_i_p_t, a file containing shell
          commands.  A subshell is spawned to execute it.  This
          subshell reinitializes itself, so that the effect is as if a
          new shell had been invoked to handle the script, with the



     Page 25                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          exception that the locations of commands remembered by the
          parent (see hhhhaaaasssshhhh below under SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS) are
          retained by the child.

          If the program is a file beginning with ####!!!!, the remainder of
          the first line specifies an interpreter for the program.
          The shell executes the specified interpreter on operating
          systems that do not handle this executable format
          themselves.  The arguments to the interpreter consist of a
          single optional argument following the interpreter name on
          the first line of the program, followed by the name of the
          program, followed by the command arguments, if any.

     EEEENNNNVVVVIIIIRRRROOOONNNNMMMMEEEENNNNTTTT
          When a program is invoked it is given an array of strings
          called the _e_n_v_i_r_o_n_m_e_n_t.  This is a list of _n_a_m_e-_v_a_l_u_e pairs,
          of the form _n_a_m_e=_v_a_l_u_e.

          The shell allows you to manipulate the environment in
          several ways.  On invocation, the shell scans its own
          environment and creates a parameter for each name found,
          automatically marking it for _e_x_p_o_r_t to child processes.
          Executed commands inherit the environment.  The eeeexxxxppppoooorrrrtttt and
          ddddeeeeccccllllaaaarrrreeee ----xxxx commands allow parameters and functions to be
          added to and deleted from the environment.  If the value of
          a parameter in the environment is modified, the new value
          becomes part of the environment, replacing the old.  The
          environment inherited by any executed command consists of
          the shell's initial environment, whose values may be
          modified in the shell, less any pairs removed by the uuuunnnnsssseeeetttt
          command, plus any additions via the eeeexxxxppppoooorrrrtttt and ddddeeeeccccllllaaaarrrreeee ----xxxx
          commands.

          The environment for any _s_i_m_p_l_e _c_o_m_m_a_n_d or function may be
          augmented temporarily by prefixing it with parameter
          assignments, as described above in PPPPAAAARRRRAAAAMMMMEEEETTTTEEEERRRRSSSS.  These
          assignment statements affect only the environment seen by
          that command.

          If the ----kkkk flag is set (see the sssseeeetttt builtin command below),
          then _a_l_l parameter assignments are placed in the environment
          for a command, not just those that precede the command name.

          When bbbbaaaasssshhhh invokes an external command, the variable ____ is set
          to the full path name of the command and passed to that
          command in its environment.

     EEEEXXXXIIIITTTT SSSSTTTTAAAATTTTUUUUSSSS
          For the purposes of the shell, a command which exits with a
          zero exit status has succeeded.  An exit status of zero
          indicates success.  A non-zero exit status indicates
          failure.  When a command terminates on a fatal signal, bbbbaaaasssshhhh



     Page 26                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          uses the value of 128+ssssiiiiggggnnnnaaaallll as the exit status.

          If a command is not found, the child process created to
          execute it returns a status of 127.  If a command is found
          but is not executable, the return status is 126.

          BBBBaaaasssshhhh itself returns the exit status of the last command
          executed, unless a syntax error occurs, in which case it
          exits with a non-zero value.  See also the eeeexxxxiiiitttt builtin
          command below.

     PPPPRRRROOOOMMMMPPPPTTTTIIIINNNNGGGG
          When executing interactively, bbbbaaaasssshhhh displays the primary
          prompt PPPPSSSS1111 when it is ready to read a command, and the
          secondary prompt PPPPSSSS2222 when it needs more input to complete a
          command.  BBBBaaaasssshhhh allows these prompt strings to be customized
          by inserting a number of backslash-escaped special
          characters that are decoded as follows:
               \\\\tttt   the current time in HH:MM:SS format
               \\\\dddd   the date in "Weekday Month Date" format (e.g.,
                    "Tue May 26")
               \\\\nnnn   newline
               \\\\ssss   the name of the shell, the basename of $$$$0000 (the
                    portion following the final slash)
               \\\\wwww   the current working directory
               \\\\WWWW   the basename of the current working directory
               \\\\uuuu   the username of the current user
               \\\\hhhh   the hostname
               \\\\####   the command number of this command
               \\\\!!!!   the history number of this command
               \\\\$$$$   if the effective UID is 0, a ####, otherwise a $$$$
               \\\\nnnnnnnnnnnn the character corresponding to the octal number
                    nnnnnnnnnnnn
               \\\\\\\\   a backslash
               \\\\[[[[   begin a sequence of non-printing characters, which
                    could be used to embed a terminal control sequence
                    into the prompt
               \\\\]]]]   end a sequence of non-printing characters

          The command number and the history number are usually
          different: the history number of a command is its position
          in the history list, which may include commands restored
          from the history file (see HHHHIIIISSSSTTTTOOOORRRRYYYY below), while the command
          number is the position in the sequence of commands executed
          during the current shell session.  After the string is
          decoded, it is expanded via parameter expansion, command
          substitution, arithmetic expansion, and word splitting.

     RRRREEEEAAAADDDDLLLLIIIINNNNEEEE
          This is the library that handles reading input when using an
          interactive shell, unless the ----nnnnoooolllliiiinnnneeeeeeeeddddiiiittttiiiinnnngggg option is
          given.  By default, the line editing commands are similar to



     Page 27                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          those of emacs.  A vi-style line editing interface is also
          available.

          In this section, the emacs-style notation is used to denote
          keystrokes.  Control keys are denoted by C-_k_e_y, e.g., C-n
          means Control-N.  Similarly, _m_e_t_a keys are denoted by M-_k_e_y,
          so M-x means Meta-X.  (On keyboards without a _m_e_t_a key, M-_x
          means ESC _x, i.e., press the Escape key then the _x key.
          This makes ESC the _m_e_t_a _p_r_e_f_i_x.  The combination M-C-_x means
          ESC-Control-_x, or press the Escape key then hold the Control
          key while pressing the _x key.)

          The default key-bindings may be changed with an ~/._i_n_p_u_t_r_c
          file.  The value of the shell variable IIIINNNNPPPPUUUUTTTTRRRRCCCC, if set, is
          used instead of ~/._i_n_p_u_t_r_c.  Other programs that use this
          library may add their own commands and bindings.

          For example, placing

               M-Control-u: universal-argument
          or
               C-Meta-u: universal-argument
          into the ~/._i_n_p_u_t_r_c would make M-C-u execute the readline
          command _u_n_i_v_e_r_s_a_l-_a_r_g_u_m_e_n_t.

          The following symbolic character names are recognized:
          _R_U_B_O_U_T, _D_E_L, _E_S_C, _L_F_D, _N_E_W_L_I_N_E, _R_E_T, _R_E_T_U_R_N, _S_P_C, _S_P_A_C_E, and
          _T_A_B.  In addition to command names, readline allows keys to
          be bound to a string that is inserted when the key is
          pressed (a _m_a_c_r_o).

          Readline is customized by putting commands in an
          initialization file.  The name of this file is taken from
          the value of the IIIINNNNPPPPUUUUTTTTRRRRCCCC variable.  If that variable is
          unset, the default is ~/._i_n_p_u_t_r_c.  When a program which uses
          the readline library starts up, the init file is read, and
          the key bindings and variables are set.  There are only a
          few basic constructs allowed in the readline init file.
          Blank lines are ignored.  Lines beginning with a #### are
          comments.  Lines beginning with a $$$$ indicate conditional
          constructs.  Other lines denote key bindings and variable
          settings.

          The syntax for controlling key bindings in the ~/._i_n_p_u_t_r_c
          file is simple.  All that is required is the name of the
          command or the text of a macro and a key sequence to which
          it should be bound. The name may be specified in one of two
          ways: as a symbolic key name, possibly with _M_e_t_a- or
          _C_o_n_t_r_o_l- prefixes, or as a key sequence.  When using the
          form kkkkeeeeyyyynnnnaaaammmmeeee:_f_u_n_c_t_i_o_n-_n_a_m_e or _m_a_c_r_o, _k_e_y_n_a_m_e is the name of
          a key spelled out in English.  For example:




     Page 28                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               Control-u: universal-argument
               Meta-Rubout: backward-kill-word
               Control-o: ">&output"

          In the above example, _C-_u is bound to the function
          uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt, _M-_D_E_L is bound to the function
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----wwwwoooorrrrdddd, and _C-_o is bound to run the macro
          expressed on the right hand side (that is, to insert the
          text >&_o_u_t_p_u_t into the line).

          In the second form, """"kkkkeeeeyyyysssseeeeqqqq"""":_f_u_n_c_t_i_o_n-_n_a_m_e or _m_a_c_r_o, kkkkeeeeyyyysssseeeeqqqq
          differs from kkkkeeeeyyyynnnnaaaammmmeeee above in that strings denoting an
          entire key sequence may be specified by placing the sequence
          within double quotes.  Some GNU Emacs style key escapes can
          be used, as in the following example.

               "\C-u": universal-argument
               "\C-x\C-r": re-read-init-file
               "\e[11~": "Function Key 1"

          In this example, _C-_u is again bound to the function
          uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt.  _C-_x _C-_r is bound to the function
          rrrreeee----rrrreeeeaaaadddd----iiiinnnniiiitttt----ffffiiiilllleeee, and _E_S_C [ _1 _1 ~ is bound to insert the
          text FFFFuuuunnnnccccttttiiiioooonnnn KKKKeeeeyyyy 1111.  The full set of escape sequences is

               \\\\CCCC----  control prefix

               \\\\MMMM----  meta prefix

               \\\\eeee   an escape character

               \\\\\\\\   backslash

               \\\\""""   literal "

               \\\\''''   literal '

          When entering the text of a macro, single or double quotes
          should be used to indicate a macro definition.  Unquoted
          text is assumed to be a function name.  Backslash will quote
          any character in the macro text, including " and '.

          BBBBaaaasssshhhh allows the current readline key bindings to be
          displayed or modified with the bbbbiiiinnnndddd builtin command.  The
          editing mode may be switched during interactive use by using
          the ----oooo option to the sssseeeetttt builtin command (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN
          CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).

          Readline has variables that can be used to further customize
          its behavior.  A variable may be set in the _i_n_p_u_t_r_c file
          with a statement of the form




     Page 29                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               sssseeeetttt _v_a_r_i_a_b_l_e-_n_a_m_e _v_a_l_u_e

          Except where noted, readline variables can take the values
          OOOOnnnn or OOOOffffffff.  The variables and their default values are:

          hhhhoooorrrriiiizzzzoooonnnnttttaaaallll----ssssccccrrrroooollllllll----mmmmooooddddeeee ((((OOOOffffffff))))
               When set to OOOOnnnn, makes readline use a single line for
               display, scrolling the input horizontally on a single
               screen line when it becomes longer than the screen
               width rather than wrapping to a new line.
          eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee ((((eeeemmmmaaaaccccssss))))
               Controls whether readline begins with a set of key
               bindings similar to _e_m_a_c_s or _v_i.  eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee can be
               set to either eeeemmmmaaaaccccssss or vvvviiii.
          mmmmaaaarrrrkkkk----mmmmooooddddiiiiffffiiiieeeedddd----lllliiiinnnneeeessss ((((OOOOffffffff))))
               If set to OOOOnnnn, history lines that have been modified are
               displayed with a preceding asterisk (****).
          bbbbeeeellllllll----ssssttttyyyylllleeee ((((aaaauuuuddddiiiibbbblllleeee))))
               Controls what happens when readline wants to ring the
               terminal bell.  If set to nnnnoooonnnneeee, readline never rings
               the bell.  If set to vvvviiiissssiiiibbbblllleeee, readline uses a visible
               bell if one is available.  If set to aaaauuuuddddiiiibbbblllleeee, readline
               attempts to ring the terminal's bell.
          ccccoooommmmmmmmeeeennnntttt----bbbbeeeeggggiiiinnnn ((((````````####''''''''))))
               The string that is inserted in vvvviiii mode when the
               vvvviiii----ccccoooommmmmmmmeeeennnntttt command is executed.
          mmmmeeeettttaaaa----ffffllllaaaagggg ((((OOOOffffffff))))
               If set to OOOOnnnn, readline will enable eight-bit input
               (that is, it will not strip the high bit from the
               characters it reads), regardless of what the terminal
               claims it can support.
          ccccoooonnnnvvvveeeerrrrtttt----mmmmeeeettttaaaa ((((OOOOnnnn))))
               If set to OOOOnnnn, readline will convert characters with the
               eighth bit set to an ASCII key sequence by stripping
               the eighth bit and prepending an escape character (in
               effect, using escape as the _m_e_t_a _p_r_e_f_i_x).
          oooouuuuttttppppuuuutttt----mmmmeeeettttaaaa ((((OOOOffffffff))))
               If set to OOOOnnnn, readline will display characters with the
               eighth bit set directly rather than as a meta-prefixed
               escape sequence.
          ccccoooommmmpppplllleeeettttiiiioooonnnn----qqqquuuueeeerrrryyyy----iiiitttteeeemmmmssss ((((111100000000))))
               This determines when the user is queried about viewing
               the number of possible completions generated by the
               ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss command.  It may be set to any
               integer value greater than or equal to zero.  If the
               number of possible completions is greater than or equal
               to the value of this variable, the user is asked
               whether or not he wishes to view them; otherwise they
               are simply listed on the terminal.
          kkkkeeeeyyyymmmmaaaapppp ((((eeeemmmmaaaaccccssss))))
               Set the current readline keymap.  The set of legal
               keymap names is _e_m_a_c_s, _e_m_a_c_s-_s_t_a_n_d_a_r_d, _e_m_a_c_s-_m_e_t_a,



     Page 30                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               _e_m_a_c_s-_c_t_l_x, _v_i_, _v_i_-_m_o_v_e_, _v_i_-_c_o_m_m_a_n_d, and _v_i-_i_n_s_e_r_t.  _v_i
               is equivalent to _v_i-_c_o_m_m_a_n_d; _e_m_a_c_s is equivalent to
               _e_m_a_c_s-_s_t_a_n_d_a_r_d.  The default value is _e_m_a_c_s; the value
               of eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee also affects the default keymap.
          sssshhhhoooowwww----aaaallllllll----iiiiffff----aaaammmmbbbbiiiigggguuuuoooouuuussss ((((OOOOffffffff))))
               This alters the default behavior of the completion
               functions.  If set to oooonnnn, words which have more than
               one possible completion cause the matches to be listed
               immediately instead of ringing the bell.
          eeeexxxxppppaaaannnndddd----ttttiiiillllddddeeee ((((OOOOffffffff))))
               If set to oooonnnn, tilde expansion is performed when
               readline attempts word completion.

          Readline implements a facility similar in spirit to the
          conditional compilation features of the C preprocessor which
          allows key bindings and variable settings to be performed as
          the result of tests.  There are three parser directives
          used.

          $$$$iiiiffff  The $$$$iiiiffff construct allows bindings to be made based on
               the editing mode, the terminal being used, or the
               application using readline.  The text of the test
               extends to the end of the line; no characters are
               required to isolate it.

               mmmmooooddddeeee The mmmmooooddddeeee==== form of the $$$$iiiiffff directive is used to
                    test whether readline is in emacs or vi mode.
                    This may be used in conjunction with the sssseeeetttt
                    kkkkeeeeyyyymmmmaaaapppp command, for instance, to set bindings in
                    the _e_m_a_c_s-_s_t_a_n_d_a_r_d and _e_m_a_c_s-_c_t_l_x keymaps only if
                    readline is starting out in emacs mode.

               tttteeeerrrrmmmm The tttteeeerrrrmmmm==== form may be used to include terminal-
                    specific key bindings, perhaps to bind the key
                    sequences output by the terminal's function keys.
                    The word on the right side of the ==== is tested
                    against the full name of the terminal and the
                    portion of the terminal name before the first ----.
                    This allows _s_u_n to match both _s_u_n and _s_u_n-_c_m_d, for
                    instance.

               aaaapppppppplllliiiiccccaaaattttiiiioooonnnn
                    The aaaapppppppplllliiiiccccaaaattttiiiioooonnnn construct is used to include
                    application-specific settings.  Each program using
                    the readline library sets the _a_p_p_l_i_c_a_t_i_o_n _n_a_m_e,
                    and an initialization file can test for a
                    particular value.  This could be used to bind key
                    sequences to functions useful for a specific
                    program.  For instance, the following command adds
                    a key sequence that quotes the current or previous
                    word in Bash:
                    $$$$iiiiffff Bash



     Page 31                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                    # Quote the current or previous word
                    "\C-xq": "\eb\"\ef\""
                    $$$$eeeennnnddddiiiiffff

          $$$$eeeennnnddddiiiiffff
               This command, as you saw in the previous example,
               terminates an $$$$iiiiffff command.

          $$$$eeeellllsssseeee
               Commands in this branch of the $$$$iiiiffff directive are
               executed if the test fails.

          Readline commands may be given numeric _a_r_g_u_m_e_n_t_s, which
          normally act as a repeat count.  Sometimes, however, it is
          the sign of the argument that is significant.  Passing a
          negative argument to a command that acts in the forward
          direction (e.g., kkkkiiiillllllll----lllliiiinnnneeee) causes that command to act in a
          backward direction.  Commands whose behavior with arguments
          deviates from this are noted.

          When a command is described as _k_i_l_l_i_n_g text, the text
          deleted is saved for possible future retrieval (_y_a_n_k_i_n_g).
          The killed text is saved in a _k_i_l_l-_r_i_n_g.  Consecutive kills
          cause the text to be accumulated into one unit, which can be
          yanked all at once. Commands which do not kill text separate
          the chunks of text on the kill-ring.

          The following is a list of the names of the commands and the
          default key sequences to which they are bound.

        CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr MMMMoooovvvviiiinnnngggg
          bbbbeeeeggggiiiinnnnnnnniiiinnnngggg----ooooffff----lllliiiinnnneeee ((((CCCC----aaaa))))
               Move to the start of the current line.
          eeeennnndddd----ooooffff----lllliiiinnnneeee ((((CCCC----eeee))))
               Move to the end of the line.
          ffffoooorrrrwwwwaaaarrrrdddd----cccchhhhaaaarrrr ((((CCCC----ffff))))
               Move forward a character.
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----cccchhhhaaaarrrr ((((CCCC----bbbb))))
               Move back a character.
          ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd ((((MMMM----ffff))))
               Move forward to the end of the next word.  Words are
               composed of alphanumeric characters (letters and
               digits).
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd ((((MMMM----bbbb))))
               Move back to the start of this, or the previous, word.
               Words are composed of alphanumeric characters (letters
               and digits).
          cccclllleeeeaaaarrrr----ssssccccrrrreeeeeeeennnn ((((CCCC----llll))))
               Clear the screen leaving the current line at the top of
               the screen.  With an argument, refresh the current line
               without clearing the screen.
          rrrreeeeddddrrrraaaawwww----ccccuuuurrrrrrrreeeennnntttt----lllliiiinnnneeee



     Page 32                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               Refresh the current line.  By default, this is unbound.

        CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr MMMMaaaannnniiiippppuuuullllaaaattttiiiinnnngggg tttthhhheeee HHHHiiiissssttttoooorrrryyyy
          aaaacccccccceeeepppptttt----lllliiiinnnneeee ((((NNNNeeeewwwwlllliiiinnnneeee,,,, RRRReeeettttuuuurrrrnnnn))))
               Accept the line regardless of where the cursor is.  If
               this line is non-empty, add it to the history list
               according to the state of the HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL variable.  If
               the line is a modified history line, then restore the
               history line to its original state.
          pppprrrreeeevvvviiiioooouuuussss----hhhhiiiissssttttoooorrrryyyy ((((CCCC----pppp))))
               Fetch the previous command from the history list,
               moving back in the list.
          nnnneeeexxxxtttt----hhhhiiiissssttttoooorrrryyyy ((((CCCC----nnnn))))
               Fetch the next command from the history list, moving
               forward in the list.
          bbbbeeeeggggiiiinnnnnnnniiiinnnngggg----ooooffff----hhhhiiiissssttttoooorrrryyyy ((((MMMM----<<<<))))
               Move to the first line in the history.
          eeeennnndddd----ooooffff----hhhhiiiissssttttoooorrrryyyy ((((MMMM---->>>>))))
               Move to the end of the input history, i.e., the line
               currently being entered.
          rrrreeeevvvveeeerrrrsssseeee----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((CCCC----rrrr))))
               Search backward starting at the current line and moving
               `up' through the history as necessary.  This is an
               incremental search.
          ffffoooorrrrwwwwaaaarrrrdddd----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((CCCC----ssss))))
               Search forward starting at the current line and moving
               `down' through the history as necessary.  This is an
               incremental search.
          nnnnoooonnnn----iiiinnnnccccrrrreeeemmmmeeeennnnttttaaaallll----rrrreeeevvvveeeerrrrsssseeee----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((MMMM----pppp))))
               Search backward through the history starting at the
               current line using a non-incremental search for a
               string supplied by the user.
          nnnnoooonnnn----iiiinnnnccccrrrreeeemmmmeeeennnnttttaaaallll----ffffoooorrrrwwwwaaaarrrrdddd----sssseeeeaaaarrrrcccchhhh----hhhhiiiissssttttoooorrrryyyy ((((MMMM----nnnn))))
               Search forward through the history using a
               non-incremental search for a string supplied by the
               user.
          hhhhiiiissssttttoooorrrryyyy----sssseeeeaaaarrrrcccchhhh----ffffoooorrrrwwwwaaaarrrrdddd
               Search forward through the history for the string of
               characters between the start of the current line and
               the current point.  This is a non-incremental search.
               By default, this command is unbound.
          hhhhiiiissssttttoooorrrryyyy----sssseeeeaaaarrrrcccchhhh----bbbbaaaacccckkkkwwwwaaaarrrrdddd
               Search backward through the history for the string of
               characters between the start of the current line and
               the current point.  This is a non-incremental search.
               By default, this command is unbound.
          yyyyaaaannnnkkkk----nnnntttthhhh----aaaarrrrgggg ((((MMMM----CCCC----yyyy))))
               Insert the first argument to the previous command
               (usually the second word on the previous line) at point
               (the current cursor position).  With an argument _n,
               insert the _nth word from the previous command (the
               words in the previous command begin with word 0).  A



     Page 33                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               negative argument inserts the _nth word from the end of
               the previous command.
          yyyyaaaannnnkkkk----llllaaaasssstttt----aaaarrrrgggg ((((MMMM----....,,,, MMMM----____))))
               Insert the last argument to the previous command (the
               last word on the previous line).  With an argument,
               behave exactly like @code{yank-nth-arg}.
          sssshhhheeeellllllll----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee ((((MMMM----CCCC----eeee))))
               Expand the line the way the shell does when it reads
               it.  This performs alias and history expansion as well
               as all of the shell word expansions.  See HHHHIIIISSSSTTTTOOOORRRRYYYY
               EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below for a description of history expansion.
          hhhhiiiissssttttoooorrrryyyy----eeeexxxxppppaaaannnndddd----lllliiiinnnneeee ((((MMMM----^^^^))))
               Perform history expansion on the current line.  See
               HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN below for a description of history
               expansion.
          iiiinnnnsssseeeerrrrtttt----llllaaaasssstttt----aaaarrrrgggguuuummmmeeeennnntttt ((((MMMM----....,,,, MMMM----____))))
               A synonym for yyyyaaaannnnkkkk----llllaaaasssstttt----aaaarrrrgggg.
          ooooppppeeeerrrraaaatttteeee----aaaannnndddd----ggggeeeetttt----nnnneeeexxxxtttt ((((CCCC----oooo))))
               Accept the current line for execution and fetch the
               next line relative to the current line from the history
               for editing.  Any argument is ignored.

        CCCCoooommmmmmmmaaaannnnddddssss ffffoooorrrr CCCChhhhaaaannnnggggiiiinnnngggg TTTTeeeexxxxtttt
          ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr ((((CCCC----dddd))))
               Delete the character under the cursor.  If point is at
               the beginning of the line, there are no characters in
               the line, and the last character typed was not CCCC----dddd,
               then return EEEEOOOOFFFF.
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----ddddeeeelllleeeetttteeee----cccchhhhaaaarrrr ((((RRRRuuuubbbboooouuuutttt))))
               Delete the character behind the cursor.  When given a
               numeric argument, save the deleted text on the
               kill-ring.
          qqqquuuuooootttteeeedddd----iiiinnnnsssseeeerrrrtttt ((((CCCC----qqqq,,,, CCCC----vvvv))))
               Add the next character that you type to the line
               verbatim.  This is how to insert characters like CCCC----qqqq,
               for example.
          ttttaaaabbbb----iiiinnnnsssseeeerrrrtttt ((((CCCC----vvvv TTTTAAAABBBB))))
               Insert a tab character.
          sssseeeellllffff----iiiinnnnsssseeeerrrrtttt ((((aaaa,,,, bbbb,,,, AAAA,,,, 1111,,,, !!!!,,,, ............))))
               Insert the character typed.
          ttttrrrraaaannnnssssppppoooosssseeee----cccchhhhaaaarrrrssss ((((CCCC----tttt))))
               Drag the character before point forward over the
               character at point.  Point moves forward as well.  If
               point is at the end of the line, then transpose the two
               characters before point.  Negative arguments don't
               work.
          ttttrrrraaaannnnssssppppoooosssseeee----wwwwoooorrrrddddssss ((((MMMM----tttt))))
               Drag the word behind the cursor past the word in front
               of the cursor moving the cursor over that word as well.
          uuuuppppccccaaaasssseeee----wwwwoooorrrrdddd ((((MMMM----uuuu))))
               Uppercase the current (or following) word.  With a
               negative argument, do the previous word, but do not



     Page 34                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               move point.
          ddddoooowwwwnnnnccccaaaasssseeee----wwwwoooorrrrdddd ((((MMMM----llll))))
               Lowercase the current (or following) word.  With a
               negative argument, do the previous word, but do not
               move point.
          ccccaaaappppiiiittttaaaalllliiiizzzzeeee----wwwwoooorrrrdddd ((((MMMM----cccc))))
               Capitalize the current (or following) word.  With a
               negative argument, do the previous word, but do not
               move point.

        KKKKiiiilllllllliiiinnnngggg aaaannnndddd YYYYaaaannnnkkkkiiiinnnngggg
          kkkkiiiillllllll----lllliiiinnnneeee ((((CCCC----kkkk))))
               Kill the text from the current cursor position to the
               end of the line.
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----lllliiiinnnneeee ((((CCCC----xxxx CCCC----RRRRuuuubbbboooouuuutttt))))
               Kill backward to the beginning of the line.
          uuuunnnniiiixxxx----lllliiiinnnneeee----ddddiiiissssccccaaaarrrrdddd ((((CCCC----uuuu))))
               Kill backward from point to the beginning of the line.
          kkkkiiiillllllll----wwwwhhhhoooolllleeee----lllliiiinnnneeee
               Kill all characters on the current line, no matter
               where the cursor is.  By default, this is unbound.
          kkkkiiiillllllll----wwwwoooorrrrdddd ((((MMMM----dddd))))
               Kill from the cursor to the end of the current word, or
               if between words, to the end of the next word.  Word
               boundaries are the same as those used by ffffoooorrrrwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
          bbbbaaaacccckkkkwwwwaaaarrrrdddd----kkkkiiiillllllll----wwwwoooorrrrdddd ((((MMMM----RRRRuuuubbbboooouuuutttt))))
               Kill the word behind the cursor.  Word boundaries are
               the same as those used by bbbbaaaacccckkkkwwwwaaaarrrrdddd----wwwwoooorrrrdddd.
          uuuunnnniiiixxxx----wwwwoooorrrrdddd----rrrruuuubbbboooouuuutttt ((((CCCC----wwww))))
               Kill the word behind the cursor, using white space as a
               word boundary.  The word boundaries are different from
               backward-kill-word.
          ddddeeeelllleeeetttteeee----hhhhoooorrrriiiizzzzoooonnnnttttaaaallll----ssssppppaaaacccceeee
               Delete all spaces and tabs around point.  By default,
               this is unbound.
          yyyyaaaannnnkkkk ((((CCCC----yyyy))))
               Yank the top of the kill ring into the buffer at the
               cursor.
          yyyyaaaannnnkkkk----ppppoooopppp ((((MMMM----yyyy))))
               Rotate the kill-ring, and yank the new top.  Only works
               following yyyyaaaannnnkkkk or yyyyaaaannnnkkkk----ppppoooopppp.

        NNNNuuuummmmeeeerrrriiiicccc AAAArrrrgggguuuummmmeeeennnnttttssss
          ddddiiiiggggiiiitttt----aaaarrrrgggguuuummmmeeeennnntttt ((((MMMM----0000,,,, MMMM----1111,,,, ............,,,, MMMM--------))))
               Add this digit to the argument already accumulating, or
               start a new argument.  M-- starts a negative argument.
          uuuunnnniiiivvvveeeerrrrssssaaaallll----aaaarrrrgggguuuummmmeeeennnntttt
               Each time this is executed, the argument count is
               multiplied by four.  The argument count is initially
               one, so executing this function the first time makes
               the argument count four.  By default, this is not bound
               to a key.



     Page 35                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



        CCCCoooommmmpppplllleeeettttiiiinnnngggg
          ccccoooommmmpppplllleeeetttteeee ((((TTTTAAAABBBB))))
               Attempt to perform completion on the text before point.
               BBBBaaaasssshhhh attempts completion treating the text as a
               variable (if the text begins with $$$$), username (if the
               text begins with ~~~~), hostname (if the text begins with
               @@@@), or command (including aliases and functions) in
               turn.  If none of these produces a match, filename
               completion is attempted.
          ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((MMMM----????))))
               List the possible completions of the text before point.
          iiiinnnnsssseeeerrrrtttt----ccccoooommmmpppplllleeeettttiiiioooonnnnssss
               Insert all completions of the text before point that
               would have been generated by ppppoooossssssssiiiibbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss.  By
               default, this is not bound to a key.
          ccccoooommmmpppplllleeeetttteeee----ffffiiiilllleeeennnnaaaammmmeeee ((((MMMM----////))))
               Attempt filename completion on the text before point.
          ppppoooossssssssiiiibbbblllleeee----ffffiiiilllleeeennnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx ////))))
               List the possible completions of the text before point,
               treating it as a filename.
          ccccoooommmmpppplllleeeetttteeee----uuuusssseeeerrrrnnnnaaaammmmeeee ((((MMMM----~~~~))))
               Attempt completion on the text before point, treating
               it as a username.
          ppppoooossssssssiiiibbbblllleeee----uuuusssseeeerrrrnnnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx ~~~~))))
               List the possible completions of the text before point,
               treating it as a username.
          ccccoooommmmpppplllleeeetttteeee----vvvvaaaarrrriiiiaaaabbbblllleeee ((((MMMM----$$$$))))
               Attempt completion on the text before point, treating
               it as a shell variable.
          ppppoooossssssssiiiibbbblllleeee----vvvvaaaarrrriiiiaaaabbbblllleeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx $$$$))))
               List the possible completions of the text before point,
               treating it as a shell variable.
          ccccoooommmmpppplllleeeetttteeee----hhhhoooossssttttnnnnaaaammmmeeee ((((MMMM----@@@@))))
               Attempt completion on the text before point, treating
               it as a hostname.
          ppppoooossssssssiiiibbbblllleeee----hhhhoooossssttttnnnnaaaammmmeeee----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx @@@@))))
               List the possible completions of the text before point,
               treating it as a hostname.
          ccccoooommmmpppplllleeeetttteeee----ccccoooommmmmmmmaaaannnndddd ((((MMMM----!!!!))))
               Attempt completion on the text before point, treating
               it as a command name.  Command completion attempts to
               match the text against aliases, reserved words, shell
               functions, builtins, and finally executable filenames,
               in that order.
          ppppoooossssssssiiiibbbblllleeee----ccccoooommmmmmmmaaaannnndddd----ccccoooommmmpppplllleeeettttiiiioooonnnnssss ((((CCCC----xxxx !!!!))))
               List the possible completions of the text before point,
               treating it as a command name.
          ddddyyyynnnnaaaammmmiiiicccc----ccccoooommmmpppplllleeeetttteeee----hhhhiiiissssttttoooorrrryyyy ((((MMMM----TTTTAAAABBBB))))
               Attempt completion on the text before point, comparing
               the text against lines from the history list for
               possible completion matches.
          ccccoooommmmpppplllleeeetttteeee----iiiinnnnttttoooo----bbbbrrrraaaacccceeeessss ((((MMMM----{{{{))))



     Page 36                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               Perform filename completion and return the list of
               possible completions enclosed within braces so the list
               is available to the shell (see BBBBrrrraaaacccceeee EEEExxxxppppaaaannnnssssiiiioooonnnn above).

        KKKKeeeeyyyybbbbooooaaaarrrrdddd MMMMaaaaccccrrrroooossss
          ssssttttaaaarrrrtttt----kkkkbbbbdddd----mmmmaaaaccccrrrroooo ((((CCCC----xxxx (((())))
               Begin saving the characters typed into the current
               keyboard macro.
          eeeennnndddd----kkkkbbbbdddd----mmmmaaaaccccrrrroooo ((((CCCC----xxxx ))))))))
               Stop saving the characters typed into the current
               keyboard macro and save the definition.
          ccccaaaallllllll----llllaaaasssstttt----kkkkbbbbdddd----mmmmaaaaccccrrrroooo ((((CCCC----xxxx eeee))))
               Re-execute the last keyboard macro defined, by making
               the characters in the macro appear as if typed at the
               keyboard.

        MMMMiiiisssscccceeeellllllllaaaannnneeeeoooouuuussss
          rrrreeee----rrrreeeeaaaadddd----iiiinnnniiiitttt----ffffiiiilllleeee ((((CCCC----xxxx CCCC----rrrr))))
               Read in the contents of your init file, and incorporate
               any bindings or variable assignments found there.
          aaaabbbboooorrrrtttt ((((CCCC----gggg))))
               Abort the current editing command and ring the
               terminal's bell (subject to the setting of bbbbeeeellllllll----ssssttttyyyylllleeee).
          ddddoooo----uuuuppppppppeeeerrrrccccaaaasssseeee----vvvveeeerrrrssssiiiioooonnnn ((((MMMM----aaaa,,,, MMMM----bbbb,,,, ............))))
               Run the command that is bound to the corresponding
               uppercase character.
          pppprrrreeeeffffiiiixxxx----mmmmeeeettttaaaa ((((EEEESSSSCCCC))))
               Metafy the next character typed.  EEEESSSSCCCC ffff is equivalent
               to MMMMeeeettttaaaa----ffff.
          uuuunnnnddddoooo ((((CCCC----____,,,, CCCC----xxxx CCCC----uuuu))))
               Incremental undo, separately remembered for each line.
          rrrreeeevvvveeeerrrrtttt----lllliiiinnnneeee ((((MMMM----rrrr))))
               Undo all changes made to this line.  This is like
               typing the uuuunnnnddddoooo command enough times to return the line
               to its initial state.
          ttttiiiillllddddeeee----eeeexxxxppppaaaannnndddd ((((MMMM----~~~~))))
               Perform tilde expansion on the current word.
          dddduuuummmmpppp----ffffuuuunnnnccccttttiiiioooonnnnssss
               Print all of the functions and their key bindings to
               the readline output stream.  If a numeric argument is
               supplied, the output is formatted in such a way that it
               can be made part of an _i_n_p_u_t_r_c file.
          ddddiiiissssppppllllaaaayyyy----sssshhhheeeellllllll----vvvveeeerrrrssssiiiioooonnnn ((((CCCC----xxxx CCCC----vvvv))))
               Display version information about the current instance
               of bbbbaaaasssshhhh.
          eeeemmmmaaaaccccssss----eeeeddddiiiittttiiiinnnngggg----mmmmooooddddeeee ((((CCCC----eeee))))
               When in vvvviiii editing mode, this causes a switch to eeeemmmmaaaaccccssss
               editing mode.

     HHHHIIIISSSSTTTTOOOORRRRYYYY
          When interactive, the shell provides access to the _c_o_m_m_a_n_d
          _h_i_s_t_o_r_y, the list of commands previously typed.  The text of



     Page 37                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          the last HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE commands (default 500) is saved in a
          history list.  The shell stores each command in the history
          list prior to parameter and variable expansion (see
          EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN above) but after history expansion is performed,
          subject to the values of the shell variables
          ccccoooommmmmmmmaaaannnndddd____oooorrrriiiieeeennnntttteeeedddd____hhhhiiiissssttttoooorrrryyyy and HHHHIIIISSSSTTTTCCCCOOOONNNNTTTTRRRROOOOLLLL.  On startup, the
          history is initialized from the file named by the variable
          HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE (default ~/._b_a_s_h__h_i_s_t_o_r_y).  HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE is truncated,
          if necessary, to contain no more than HHHHIIIISSSSTTTTFFFFIIIILLLLEEEESSSSIIIIZZZZEEEE lines.
          The builtin command ffffcccc (see SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below)
          may be used to list or edit and re-execute a portion of the
          history list.  The hhhhiiiissssttttoooorrrryyyy builtin can be used to display
          the history list and manipulate the history file.  When
          using the command-line editing, search commands are
          available in each editing mode that provide access to the
          history list.  When an interactive shell exits, the last
          HHHHIIIISSSSTTTTSSSSIIIIZZZZEEEE lines are copied from the history list to HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE.
          If HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE is unset, or if the history file is unwritable,
          the history is not saved.

     HHHHIIIISSSSTTTTOOOORRRRYYYY EEEEXXXXPPPPAAAANNNNSSSSIIIIOOOONNNN
          The shell supports a history expansion feature that is
          similar to the history expansion in ccccsssshhhh....  This section
          describes what syntax features are available.  This feature
          is enabled by default for interactive shells, and can be
          disabled using the ++++HHHH option to the sssseeeetttt builtin command (see
          SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS below).  Non-interactive shells do
          not perform history expansion.

          History expansion is performed immediately after a complete
          line is read, before the shell breaks it into words.  It
          takes place in two parts.  The first is to determine which
          line from the previous history to use during substitution.
          The second is to select portions of that line for inclusion
          into the current one.  The line selected from the previous
          history is the _e_v_e_n_t, and the portions of that line that are
          acted upon are _w_o_r_d_s.  The line is broken into words in the
          same fashion as when reading input, so that several
          _m_e_t_a_c_h_a_r_a_c_t_e_r-separated words surrounded by quotes are
          considered as one word.  Only backslash (\\\\) and single
          quotes can quote the history escape character, which is !!!! by
          default.

          The shell allows control of the various characters used by
          the history expansion mechanism (see the description of
          hhhhiiiissssttttcccchhhhaaaarrrrssss above under SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss).

        EEEEvvvveeeennnntttt DDDDeeeessssiiiiggggnnnnaaaattttoooorrrrssss
          An event designator is a reference to a command line entry
          in the history list.

          !!!!    Start a history substitution, except when followed by a



     Page 38                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               bbbbllllaaaannnnkkkk, newline, = or (.
          !!!!!!!!   Refer to the previous command.  This is a synonym for
               `!-1'.
          !!!!_n   Refer to command line _n.
          !!!!----_n  Refer to the current command line minus _n.
          !!!!_s_t_r_i_n_g
               Refer to the most recent command starting with _s_t_r_i_n_g.
          !!!!????_s_t_r_i_n_g[[[[????]]]]
               Refer to the most recent command containing _s_t_r_i_n_g.
          ^^^^_s_t_r_i_n_g_1^^^^_s_t_r_i_n_g_2^^^^
               Quick substitution.  Repeat the last command, replacing
               _s_t_r_i_n_g_1 with _s_t_r_i_n_g_2.  Equivalent to
               ``!!:s/_s_t_r_i_n_g_1/_s_t_r_i_n_g_2/'' (see MMMMooooddddiiiiffffiiiieeeerrrrssss below).
          !!!!####   The entire command line typed so far.

        WWWWoooorrrrdddd DDDDeeeessssiiiiggggnnnnaaaattttoooorrrrssss
          A :::: separates the event specification from the word
          designator.  It can be omitted if the word designator begins
          with a ^^^^, $$$$, ****, or %%%%.  Words are numbered from the beginning
          of the line, with the first word being denoted by a 0
          (zero).

          0000 ((((zzzzeeeerrrroooo))))
               The zeroth word.  For the shell, this is the command
               word.
          _n    The _nth word.
          ^^^^    The first argument.  That is, word 1.
          $$$$    The last argument.
          %%%%    The word matched by the most recent `?_s_t_r_i_n_g?' search.
          _x----_y  A range of words; `-_y' abbreviates `0-_y'.
          ****    All of the words but the zeroth.  This is a synonym for
               `_1-$'.  It is not an error to use **** if there is just
               one word in the event; the empty string is returned in
               that case.
          xxxx****   Abbreviates _x-$.
          xxxx----   Abbreviates _x-$ like xxxx****, but omits the last word.

        MMMMooooddddiiiiffffiiiieeeerrrrssss
          After the optional word designator, you can add a sequence
          of one or more of the following modifiers, each preceded by
          a `:'.

          hhhh    Remove a trailing pathname component, leaving only the
               head.
          rrrr    Remove a trailing suffix of the form ._x_x_x, leaving the
               basename.
          eeee    Remove all but the trailing suffix.
          tttt    Remove all leading pathname components, leaving the
               tail.
          pppp    Print the new command but do not execute it.
          qqqq    Quote the substituted words, escaping further
               substitutions.



     Page 39                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          xxxx    Quote the substituted words as with qqqq, but break into
               words at bbbbllllaaaannnnkkkkssss and newlines.
          ssss////_o_l_d////_n_e_w////
               Substitute _n_e_w for the first occurrence of _o_l_d in the
               event line.  Any delimiter can be used in place of /.
               The final delimiter is optional if it is the last
               character of the event line.  The delimiter may be
               quoted in _o_l_d and _n_e_w with a single backslash.  If &
               appears in _n_e_w, it is replaced by _o_l_d.  A single
               backslash will quote the &.
          &&&&    Repeat the previous substitution.
          gggg    Cause changes to be applied over the entire event line.
               This is used in conjunction with `::::ssss' (e.g.,
               `::::ggggssss////_o_l_d////_n_e_w////') or `::::&&&&'.  If used with `::::ssss', any
               delimiter can be used in place of /, and the final
               delimiter is optional if it is the last character of
               the event line.

     AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN
          The shell allows arithmetic expressions to be evaluated,
          under certain circumstances (see the lllleeeetttt builtin command and
          AAAArrrriiiitttthhhhmmmmeeeettttiiiicccc EEEExxxxppppaaaannnnssssiiiioooonnnn).  Evaluation is done in long integers
          with no check for overflow, though division by 0 is trapped
          and flagged as an error.  The following list of operators is
          grouped into levels of equal-precedence operators.  The
          levels are listed in order of decreasing precedence.

          ---- ++++  unary minus and plus
          !!!! ~~~~  logical and bitwise negation
          **** //// %%%%
               multiplication, division, remainder
          ++++ ----  addition, subtraction
          <<<<<<<< >>>>>>>>
               left and right bitwise shifts
          <<<<==== >>>>==== <<<< >>>>
               comparison
          ======== !!!!====
               equality and inequality
          &&&&    bitwise AND
          ^^^^    bitwise exclusive OR
          ||||    bitwise OR
          &&&&&&&&   logical AND
          ||||||||   logical OR
          ==== ****==== ////==== %%%%==== ++++==== ----====
               assignment

          Shell variables are allowed as operands; parameter expansion
          is performed before the expression is evaluated. The value
          of a parameter is coerced to a long integer within an
          expression.  A shell variable need not have its integer
          attribute turned on to be used in an expression.




     Page 40                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          Constants with a leading 0 are interpreted as octal numbers.
          A leading _0_x or _0_X denotes hexadecimal.  Otherwise, numbers
          take the form [_b_a_s_e#]n, where _b_a_s_e is a decimal number
          between 2 and 36 representing the arithmetic base, and _n is
          a number in that base.  If _b_a_s_e is omitted, then base 10 is
          used.

          Operators are evaluated in order of precedence.  Sub-
          expressions in parentheses are evaluated first and may
          override the precedence rules above.

     SSSSHHHHEEEELLLLLLLL BBBBUUUUIIIILLLLTTTTIIIINNNN CCCCOOOOMMMMMMMMAAAANNNNDDDDSSSS
          :::: [_a_r_g_u_m_e_n_t_s]
               No effect; the command does nothing beyond expanding
               _a_r_g_u_m_e_n_t_s and performing any specified redirections.  A
               zero exit code is returned.

           ....  _f_i_l_e_n_a_m_e [_a_r_g_u_m_e_n_t_s]
          ssssoooouuuurrrrcccceeee _f_i_l_e_n_a_m_e [_a_r_g_u_m_e_n_t_s]
               Read and execute commands from _f_i_l_e_n_a_m_e in the current
               shell environment and return the exit status of the
               last command executed from _f_i_l_e_n_a_m_e.  If _f_i_l_e_n_a_m_e does
               not contain a slash, pathnames in PPPPAAAATTTTHHHH are used to find
               the directory containing _f_i_l_e_n_a_m_e.  The file searched
               for in PPPPAAAATTTTHHHH need not be executable.  The current
               directory is searched if no file is found in PPPPAAAATTTTHHHH.  If
               any _a_r_g_u_m_e_n_t_s are supplied, they become the positional
               parameters when _f_i_l_e is executed.  Otherwise the
               positional parameters are unchanged.  The return status
               is the status of the last command exited within the
               script (0 if no commands are executed), and false if
               _f_i_l_e_n_a_m_e is not found.

          aaaalllliiiiaaaassss [_n_a_m_e[=_v_a_l_u_e] ...]
               AAAAlllliiiiaaaassss with no arguments prints the list of aliases in
               the form _n_a_m_e=_v_a_l_u_e on standard output.  When arguments
               are supplied, an alias is defined for each _n_a_m_e whose
               _v_a_l_u_e is given.  A trailing space in _v_a_l_u_e causes the
               next word to be checked for alias substitution when the
               alias is expanded.  For each _n_a_m_e in the argument list
               for which no _v_a_l_u_e is supplied, the name and value of
               the alias is printed.  AAAAlllliiiiaaaassss returns true unless a _n_a_m_e
               is given for which no alias has been defined.

          bbbbgggg [_j_o_b_s_p_e_c]
               Place _j_o_b_s_p_e_c in the background, as if it had been
               started with &&&&.  If _j_o_b_s_p_e_c is not present, the shell's
               notion of the _c_u_r_r_e_n_t _j_o_b is used.  bbbbgggg _j_o_b_s_p_e_c returns
               0 unless run when job control is disabled or, when run
               with job control enabled, if _j_o_b_s_p_e_c was not found or
               started without job control.




     Page 41                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] [----llllvvvvdddd] [----qqqq _n_a_m_e]
          bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] ----ffff _f_i_l_e_n_a_m_e
          bbbbiiiinnnndddd [----mmmm _k_e_y_m_a_p] _k_e_y_s_e_q:_f_u_n_c_t_i_o_n-_n_a_m_e
               Display current rrrreeeeaaaaddddlllliiiinnnneeee key and function bindings, or
               bind a key sequence to a rrrreeeeaaaaddddlllliiiinnnneeee function or macro.
               The binding syntax accepted is identical to that of
               ._i_n_p_u_t_r_c, but each binding must be passed as a separate
               argument; e.g., '"\C-x\C-r": re-read-init-file'.
               Options, if supplied, have the following meanings:
               ----mmmm _k_e_y_m_a_p
                    Use _k_e_y_m_a_p as the keymap to be affected by the
                    subsequent bindings.  Acceptable _k_e_y_m_a_p names are
                    _e_m_a_c_s, _e_m_a_c_s-_s_t_a_n_d_a_r_d, _e_m_a_c_s-_m_e_t_a, _e_m_a_c_s-_c_t_l_x, _v_i,
                    _v_i-_m_o_v_e, _v_i-_c_o_m_m_a_n_d, and _v_i-_i_n_s_e_r_t.  _v_i is
                    equivalent to _v_i-_c_o_m_m_a_n_d; _e_m_a_c_s is equivalent to
                    _e_m_a_c_s-_s_t_a_n_d_a_r_d.
               ----llll   List the names of all rrrreeeeaaaaddddlllliiiinnnneeee functions
               ----vvvv   List current function names and bindings
               ----dddd   Dump function names and bindings in such a way
                    that they can be re-read
               ----ffff _f_i_l_e_n_a_m_e
                    Read key bindings from _f_i_l_e_n_a_m_e
               ----qqqq _f_u_n_c_t_i_o_n
                    Query about which keys invoke the named _f_u_n_c_t_i_o_n

               The return value is 0 unless an unrecognized option is
               given or an error occurred.

          bbbbrrrreeeeaaaakkkk [_n]
               Exit from within a ffffoooorrrr, wwwwhhhhiiiilllleeee, or uuuunnnnttttiiiillll loop.  If _n is
               specified, break _n levels.  _n must be >_ 1.  If _n is
               greater than the number of enclosing loops, all
               enclosing loops are exited.  The return value is 0
               unless the shell is not executing a loop when bbbbrrrreeeeaaaakkkk is
               executed.

          bbbbuuuuiiiillllttttiiiinnnn _s_h_e_l_l-_b_u_i_l_t_i_n [_a_r_g_u_m_e_n_t_s]
               Execute the specified shell builtin, passing it
               _a_r_g_u_m_e_n_t_s, and return its exit status.  This is useful
               when you wish to define a function whose name is the
               same as a shell builtin, but need the functionality of
               the builtin within the function itself.  The ccccdddd builtin
               is commonly redefined this way.  The return status is
               false if _s_h_e_l_l-_b_u_i_l_t_i_n is not a shell builtin command.

          ccccdddd [_d_i_r]
               Change the current directory to _d_i_r.  The variable HHHHOOOOMMMMEEEE
               is the default _d_i_r.  The variable CCCCDDDDPPPPAAAATTTTHHHH defines the
               search path for the directory containing _d_i_r.
               Alternative directory names are separated by a colon
               (:).  A null directory name in CCCCDDDDPPPPAAAATTTTHHHH is the same as
               the current directory, i.e., ``....''.  If _d_i_r begins with



     Page 42                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               a slash (/), then CCCCDDDDPPPPAAAATTTTHHHH is not used.  An argument of ----
               is equivalent to $$$$OOOOLLLLDDDDPPPPWWWWDDDD.  The return value is true if
               the directory was successfully changed; false
               otherwise.

          ccccoooommmmmmmmaaaannnndddd [----ppppVVVVvvvv] _c_o_m_m_a_n_d [_a_r_g ...]
               Run _c_o_m_m_a_n_d with _a_r_g_s suppressing the normal shell
               function lookup. Only builtin commands or commands
               found in the PPPPAAAATTTTHHHH are executed.  If the ----pppp option is
               given, the search for _c_o_m_m_a_n_d is performed using a
               default value for PPPPAAAATTTTHHHH that is guaranteed to find all
               of the standard utilities.  If either the ----VVVV or ----vvvv
               option is supplied, a description of _c_o_m_m_a_n_d is
               printed.  The ----vvvv option causes a single word indicating
               the command or pathname used to invoke _c_o_m_m_a_n_d to be
               printed; the ----VVVV option produces a more verbose
               description.  An argument of -------- disables option
               checking for the rest of the arguments.  If the ----VVVV or
               ----vvvv option is supplied, the exit status is 0 if _c_o_m_m_a_n_d
               was found, and 1 if not.  If neither option is supplied
               and an error occurred or _c_o_m_m_a_n_d cannot be found, the
               exit status is 127.  Otherwise, the exit status of the
               ccccoooommmmmmmmaaaannnndddd builtin is the exit status of _c_o_m_m_a_n_d.

          ccccoooonnnnttttiiiinnnnuuuueeee [_n]
               Resume the next iteration of the enclosing ffffoooorrrr, wwwwhhhhiiiilllleeee,
               or uuuunnnnttttiiiillll loop.  If _n is specified, resume at the _nth
               enclosing loop.  _n must be >_ 1.  If _n is greater than
               the number of enclosing loops, the last enclosing loop
               (the `top-level' loop) is resumed.  The return value is
               0 unless the shell is not executing a loop when
               ccccoooonnnnttttiiiinnnnuuuueeee is executed.

          ddddeeeeccccllllaaaarrrreeee [----ffffrrrrxxxxiiii] [_n_a_m_e[=_v_a_l_u_e]]
          ttttyyyyppppeeeesssseeeetttt [----ffffrrrrxxxxiiii] [_n_a_m_e[=_v_a_l_u_e]]
               Declare variables and/or give them attributes.  If no
               _n_a_m_es are given, then display the values of variables
               instead.  The options can be used to restrict output to
               variables with the specified attribute.
               ----ffff   Use function names only
               ----rrrr   Make _n_a_m_es readonly.  These names cannot then be
                    assigned values by subsequent assignment
                    statements.
               ----xxxx   Mark _n_a_m_es for export to subsequent commands via
                    the environment.
               ----iiii   The variable is treated as an integer; arithmetic
                    evaluation (see AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN )))) is
                    performed when the variable is assigned a value.

               Using `+' instead of `-' turns off the attribute
               instead.  When used in a function, makes _n_a_m_es local,
               as with the llllooooccccaaaallll command.  The return value is 0



     Page 43                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               unless an illegal option is encountered, an attempt is
               made to define a function using "-f foo=bar", one of
               the _n_a_m_e_s is not a legal shell variable name, an
               attempt is made to turn off readonly status for a
               readonly variable, or an attempt is made to display a
               non-existant function with -f.

          ddddiiiirrrrssss [[[[----llll]]]] [[[[++++////----nnnn]]]]
               Display the list of currently remembered directories.
               Directories are added to the list with the ppppuuuusssshhhhdddd
               command; the ppppooooppppdddd command moves back up through the
               list.
               ++++nnnn   displays the _nth entry counting from the left of
                    the list shown by ddddiiiirrrrssss when invoked without
                    options, starting with zero.
               ----nnnn   displays the _nth entry counting from the right of
                    the list shown by ddddiiiirrrrssss when invoked without
                    options, starting with zero.
               ----llll   produces a longer listing; the default listing
                    format uses a tilde to denote the home directory.

               The return value is 0 unless an illegal option is
               supplied or _n indexes beyond the end of the directory
               stack.

          eeeecccchhhhoooo [----nnnneeeeEEEE] [_a_r_g ...]
               Output the _a_r_gs, separated by spaces.  The return
               status is always 0.  If ----nnnn is specified, the trailing
               newline is suppressed.  If the ----eeee option is given,
               interpretation of the following backslash-escaped
               characters is enabled.  The ----EEEE option disables the
               interpretation of these escape characters, even on
               systems where they are interpreted by default.
               \\\\aaaa   alert (bell)
               \\\\bbbb   backspace
               \\\\cccc   suppress trailing newline
               \\\\ffff   form feed
               \\\\nnnn   new line
               \\\\rrrr   carriage return
               \\\\tttt   horizontal tab
               \\\\vvvv   vertical tab
               \\\\\\\\   backslash
               \\\\nnnnnnnnnnnn the character whose ASCII code is _n_n_n (octal)

          eeeennnnaaaabbbblllleeee [----nnnn] [----aaaallllllll] [_n_a_m_e ...]
               Enable and disable builtin shell commands.  This allows
               the execution of a disk command which has the same name
               as a shell builtin without specifying a full pathname.
               If ----nnnn is used, each _n_a_m_e is disabled; otherwise, _n_a_m_e_s
               are enabled.  For example, to use the tttteeeesssstttt binary found
               via the PPPPAAAATTTTHHHH instead of the shell builtin version, type
               ``enable -n test''.  If no arguments are given, a list



     Page 44                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               of all enabled shell builtins is printed.  If only ----nnnn
               is supplied, a list of all disabled builtins is
               printed.  If only ----aaaallllllll is supplied, the list printed
               includes all builtins, with an indication of whether or
               not each is enabled.  eeeennnnaaaabbbblllleeee accepts ----aaaa as a synonym
               for ----aaaallllllll.  The return value is 0 unless a _n_a_m_e is not a
               shell builtin.

          eeeevvvvaaaallll [_a_r_g ...]
               The _a_r_gs are read and concatenated together into a
               single command.  This command is then read and executed
               by the shell, and its exit status is returned as the
               value of the eeeevvvvaaaallll command.  If there are no _a_r_g_s, or
               only null arguments, eeeevvvvaaaallll returns true.

          eeeexxxxeeeecccc [[----] _c_o_m_m_a_n_d [_a_r_g_u_m_e_n_t_s]]
               If _c_o_m_m_a_n_d is specified, it replaces the shell.  No new
               process is created.  The _a_r_g_u_m_e_n_t_s become the arguments
               to _c_o_m_m_a_n_d.  If the first argument is ----, the shell
               places a dash in the zeroth arg passed to _c_o_m_m_a_n_d.
               This is what login does.  If the file cannot be
               executed for some reason, a non-interactive shell
               exits, unless the shell variable nnnnoooo____eeeexxxxiiiitttt____oooonnnn____ffffaaaaiiiilllleeeedddd____eeeexxxxeeeecccc
               exists, in which case it returns failure.  An
               interactive shell returns failure if the file cannot be
               executed.  If _c_o_m_m_a_n_d is not specified, any
               redirections take effect in the current shell, and the
               return status is 0.

          eeeexxxxiiiitttt [_n]
               Cause the shell to exit with a status of _n.  If _n is
               omitted, the exit status is that of the last command
               executed.  A trap on EEEEXXXXIIIITTTT is executed before the shell
               terminates.

          eeeexxxxppppoooorrrrtttt [----nnnnffff] [_n_a_m_e[=_w_o_r_d]] ...
          eeeexxxxppppoooorrrrtttt ----pppp
               The supplied _n_a_m_e_s are marked for automatic export to
               the environment of subsequently executed commands.  If
               the ----ffff option is given, the _n_a_m_e_s refer to functions.
               If no _n_a_m_e_s are given, or if the ----pppp option is supplied,
               a list of all names that are exported in this shell is
               printed.  The ----nnnn option causes the export property to
               be removed from the named variables.  An argument of --------
               disables option checking for the rest of the arguments.
               eeeexxxxppppoooorrrrtttt returns an exit status of 0 unless an illegal
               option is encountered, one of the _n_a_m_e_s is not a legal
               shell variable name, or ----ffff is supplied with a _n_a_m_e that
               is not a function.

          ffffcccc [----eeee _e_n_a_m_e] [----nnnnllllrrrr] [_f_i_r_s_t] [_l_a_s_t]
          ffffcccc ----ssss [_p_a_t=_r_e_p] [_c_m_d]



     Page 45                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               Fix Command.  In the first form, a range of commands
               from _f_i_r_s_t to _l_a_s_t is selected from the history list.
               _F_i_r_s_t and _l_a_s_t may be specified as a string (to locate
               the last command beginning with that string) or as a
               number (an index into the history list, where a
               negative number is used as an offset from the current
               command number).  If _l_a_s_t is not specified it is set to
               the current command for listing (so that ffffcccc ----llll ----11110000
               prints the last 10 commands) and to _f_i_r_s_t otherwise.
               If _f_i_r_s_t is not specified it is set to the previous
               command for editing and -16 for listing.

               The ----nnnn flag suppresses the command numbers when
               listing.  The ----rrrr flag reverses the order of the
               commands.  If the ----llll flag is given, the commands are
               listed on standard output.  Otherwise, the editor given
               by _e_n_a_m_e is invoked on a file containing those
               commands.  If _e_n_a_m_e is not given, the value of the
               FFFFCCCCEEEEDDDDIIIITTTT variable is used, and the value of EEEEDDDDIIIITTTTOOOORRRR if
               FFFFCCCCEEEEDDDDIIIITTTT is not set.  If neither variable is set, _v_i is
               used.  When editing is complete, the edited commands
               are echoed and executed.

               In the second form, _c_o_m_m_a_n_d is re-executed after each
               instance of _p_a_t is replaced by _r_e_p.  A useful alias to
               use with this is ``r=fc -s'', so that typing ``r cc''
               runs the last command beginning with ``cc'' and typing
               ``r'' re-executes the last command.

               If the first form is used, the return value is 0 unless
               an illegal option is encountered or _f_i_r_s_t or _l_a_s_t
               specify history lines out of range.  If the ----eeee option
               is supplied, the return value is the value of the last
               command executed or failure if an error occurs with the
               temporary file of commands.  If the second form is
               used, the return status is that of the command re-
               executed, unless _c_m_d does not specify a valid history
               line, in which case ffffcccc returns failure.

          ffffgggg [_j_o_b_s_p_e_c]
               Place _j_o_b_s_p_e_c in the foreground, and make it the
               current job.  If _j_o_b_s_p_e_c is not present, the shell's
               notion of the _c_u_r_r_e_n_t _j_o_b is used.  The return value is
               that of the command placed into the foreground, or
               failure if run when job control is disabled or, when
               run with job control enabled, if _j_o_b_s_p_e_c does not
               specify a valid job or _j_o_b_s_p_e_c specifies a job that was
               started without job control.

          ggggeeeettttooooppppttttssss _o_p_t_s_t_r_i_n_g _n_a_m_e [_a_r_g_s]
               ggggeeeettttooooppppttttssss is used by shell procedures to parse positional
               parameters.  _o_p_t_s_t_r_i_n_g contains the option letters to



     Page 46                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               be recognized; if a letter is followed by a colon, the
               option is expected to have an argument, which should be
               separated from it by white space.  Each time it is
               invoked, ggggeeeettttooooppppttttssss places the next option in the shell
               variable _n_a_m_e, initializing _n_a_m_e if it does not exist,
               and the index of the next argument to be processed into
               the variable OOOOPPPPTTTTIIIINNNNDDDD.  OOOOPPPPTTTTIIIINNNNDDDD is initialized to 1 each
               time the shell or a shell script is invoked.  When an
               option requires an argument, ggggeeeettttooooppppttttssss places that
               argument into the variable OOOOPPPPTTTTAAAARRRRGGGG.  The shell does not
               reset OOOOPPPPTTTTIIIINNNNDDDD automatically; it must be manually reset
               between multiple calls to ggggeeeettttooooppppttttssss within the same shell
               invocation if a new set of parameters is to be used.

               ggggeeeettttooooppppttttssss can report errors in two ways.  If the first
               character of _o_p_t_s_t_r_i_n_g is a colon, _s_i_l_e_n_t error
               reporting is used.  In normal operation diagnostic
               messages are printed when illegal options or missing
               option arguments are encountered.  If the variable
               OOOOPPPPTTTTEEEERRRRRRRR is set to 0, no error message will be displayed,
               even if the first character of _o_p_t_s_t_r_i_n_g is not a
               colon.

               If an illegal option is seen, ggggeeeettttooooppppttttssss places ? into
               _n_a_m_e and, if not silent, prints an error message and
               unsets OOOOPPPPTTTTAAAARRRRGGGG.  If ggggeeeettttooooppppttttssss is silent, the option
               character found is placed in OOOOPPPPTTTTAAAARRRRGGGG and no diagnostic
               message is printed.

               If a required argument is not found, and ggggeeeettttooooppppttttssss is not
               silent, a question mark (????) is placed in _n_a_m_e, OOOOPPPPTTTTAAAARRRRGGGG
               is unset, and a diagnostic message is printed.  If
               ggggeeeettttooooppppttttssss is silent, then a colon (::::) is placed in _n_a_m_e
               and OOOOPPPPTTTTAAAARRRRGGGG is set to the option character found.

               ggggeeeettttooooppppttttssss normally parses the positional parameters, but
               if more arguments are given in _a_r_g_s, ggggeeeettttooooppppttttssss parses
               those instead.  ggggeeeettttooooppppttttssss returns true if an option,
               specified or unspecified, is found.  It returns false
               if the end of options is encountered or an error
               occurs.

          hhhhaaaasssshhhh [----rrrr] [_n_a_m_e]
               For each _n_a_m_e, the full pathname of the command is
               determined and remembered.  The ----rrrr option causes the
               shell to forget all remembered locations.  If no
               arguments are given, information about remembered
               commands is printed.  An argument of -------- disables option
               checking for the rest of the arguments.  The return
               status is true unless a _n_a_m_e is not found or an illegal
               option is supplied.




     Page 47                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          hhhheeeellllpppp [_p_a_t_t_e_r_n]
               Display helpful information about builtin commands.  If
               _p_a_t_t_e_r_n is specified, hhhheeeellllpppp gives detailed help on all
               commands matching _p_a_t_t_e_r_n; otherwise a list of the
               builtins is printed.  The return status is 0 unless no
               command matches _p_a_t_t_e_r_n.

          hhhhiiiissssttttoooorrrryyyy [_n]
          hhhhiiiissssttttoooorrrryyyy ----rrrrwwwwaaaannnn [_f_i_l_e_n_a_m_e]
               With no options, display the command history list with
               line numbers.  Lines listed with a **** have been
               modified.  An argument of _n lists only the last _n
               lines.  If a non-option argument is supplied, it is
               used as the name of the history file; if not, the value
               of HHHHIIIISSSSTTTTFFFFIIIILLLLEEEE is used.  Options, if supplied, have the
               following meanings:
               ----aaaa   Append the ``new'' history lines (history lines
                    entered since the beginning of the current bbbbaaaasssshhhh
                    session) to the history file
               ----nnnn   Read the history lines not already read from the
                    history file into the current history list.  These
                    are lines appended to the history file since the
                    beginning of the current bbbbaaaasssshhhh session.
               ----rrrr   Read the contents of the history file and use them
                    as the current history
               ----wwww   Write the current history to the history file,
                    overwriting the history file's contents.

               The return value is 0 unless an illegal option is
               encountered or an error occurs while reading or writing
               the history file.

          jjjjoooobbbbssss [----llllnnnnpppp] [ _j_o_b_s_p_e_c ... ]
          jjjjoooobbbbssss ----xxxx _c_o_m_m_a_n_d [ _a_r_g_s ... ]
               The first form lists the active jobs.  The ----llll option
               lists process IDs in addition to the normal
               information; the ----pppp option lists only the process ID of
               the job's process group leader.  The ----nnnn option displays
               only jobs that have changed status since last notified.
               If _j_o_b_s_p_e_c is given, output is restricted to
               information about that job.  The return status is 0
               unless an illegal option is encountered or an illegal
               _j_o_b_s_p_e_c is supplied.

               If the ----xxxx option is supplied, jjjjoooobbbbssss replaces any _j_o_b_s_p_e_c
               found in _c_o_m_m_a_n_d or _a_r_g_s with the corresponding process
               group ID, and executes _c_o_m_m_a_n_d passing it _a_r_g_s,
               returning its exit status.

          kkkkiiiillllllll [----ssss ssssiiiiggggssssppppeeeecccc | ----ssssiiiiggggssssppppeeeecccc] [_p_i_d | _j_o_b_s_p_e_c] ...
          kkkkiiiillllllll ----llll [_s_i_g_n_u_m]
               Send the signal named by _s_i_g_s_p_e_c to the processes named



     Page 48                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               by _p_i_d or _j_o_b_s_p_e_c.  _s_i_g_s_p_e_c is either a signal name
               such as SSSSIIIIGGGGKKKKIIIILLLLLLLL or a signal number.  If _s_i_g_s_p_e_c is a
               signal name, the name is case insensitive and may be
               given with or without the SSSSIIIIGGGG prefix.  If _s_i_g_s_p_e_c is
               not present, then SSSSIIIIGGGGTTTTEEEERRRRMMMM is assumed.  An argument of
               ----llll lists the signal names.  If any arguments are
               supplied when ----llll is given, the names of the specified
               signals are listed, and the return status is 0.  An
               argument of -------- disables option checking for the rest of
               the arguments.  kkkkiiiillllllll returns true if at least one
               signal was successfully sent, or false if an error
               occurs or an illegal option is encountered.

          lllleeeetttt _a_r_g [_a_r_g ...]
               Each _a_r_g is an arithmetic expression to be evaluated
               (see AAAARRRRIIIITTTTHHHHMMMMEEEETTTTIIIICCCC EEEEVVVVAAAALLLLUUUUAAAATTTTIIIIOOOONNNN).  If the last _a_r_g evaluates
               to 0, lllleeeetttt returns 1; 0 is returned otherwise.

          llllooooccccaaaallll [_n_a_m_e[=_v_a_l_u_e] ...]
               For each argument, create a local variable named _n_a_m_e,
               and assign it _v_a_l_u_e.  When llllooooccccaaaallll is used within a
               function, it causes the variable _n_a_m_e to have a visible
               scope restricted to that function and its children.
               With no operands, llllooooccccaaaallll writes a list of local
               variables to the standard output.  It is an error to
               use llllooooccccaaaallll when not within a function.  The return
               status is 0 unless llllooooccccaaaallll is used outside a function, or
               an illegal _n_a_m_e is supplied.

          llllooooggggoooouuuutttt
               Exit a login shell.

          ppppooooppppdddd [++++////----nnnn]
               Removes entries from the directory stack.  With no
               arguments, removes the top directory from the stack,
               and performs a ccccdddd to the new top directory.
               ++++nnnn   removes the _nth entry counting from the left of
                    the list shown by ddddiiiirrrrssss, starting with zero.  For
                    example: ``popd +0'' removes the first directory,
                    ``popd +1'' the second.
               ----nnnn   removes the _nth entry counting from the right of
                    the list shown by ddddiiiirrrrssss, starting with zero.  For
                    example: ``popd -0'' removes the last directory,
                    ``popd -1'' the next to last.

               If the ppppooooppppdddd command is successful, a ddddiiiirrrrssss is performed
               as well, and the return status is 0.  ppppooooppppdddd returns
               false if an illegal option is encountered, the
               directory stack is empty, a non-existent directory
               stack entry is specified, or the directory change
               fails.




     Page 49                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



          ppppuuuusssshhhhdddd [_d_i_r]
          ppppuuuusssshhhhdddd ++++////----nnnn
               Adds a directory to the top of the directory stack, or
               rotates the stack, making the new top of the stack the
               current working directory.  With no arguments,
               exchanges the top two directories and returns 0, unless
               the directory stack is empty.
               ++++nnnn   Rotates the stack so that the _nth directory
                    (counting from the left of the list shown by ddddiiiirrrrssss)
                    is at the top.
               ----nnnn   Rotates the stack so that the _nth directory
                    (counting from the right) is at the top.
               ddddiiiirrrr  adds _d_i_r to the directory stack at the top, making
                    it the new current working directory.

               If the ppppuuuusssshhhhdddd command is successful, a ddddiiiirrrrssss is performed
               as well.  If the first form is used, ppppuuuusssshhhhdddd returns 0
               unless the cd to _d_i_r fails.  With the second form,
               ppppuuuusssshhhhdddd returns 0 unless the directory stack is empty, a
               non-existant directory stack element is specified, or
               the directory change to the specified new current
               directory fails.

          ppppwwwwdddd  Print the absolute pathname of the current working
               directory.  The path printed contains no symbolic links
               if the ----PPPP option to the sssseeeetttt builtin command is set.
               See also the description of nnnnoooolllliiiinnnnkkkkssss under SSSShhhheeeellllllll
               VVVVaaaarrrriiiiaaaabbbblllleeeessss above).  The return status is 0 unless an
               error occurs while reading the pathname of the current
               directory.

          rrrreeeeaaaadddd [----rrrr] [_n_a_m_e ...]
               One line is read from the standard input, and the first
               word is assigned to the first _n_a_m_e, the second word to
               the second _n_a_m_e, and so on, with leftover words
               assigned to the last _n_a_m_e.  Only the characters in IIIIFFFFSSSS
               are recognized as word delimiters.  If no _n_a_m_e_s are
               supplied, the line read is assigned to the variable
               RRRREEEEPPPPLLLLYYYY.  The return code is zero, unless end-of-file is
               encountered.  If the ----rrrr option is given, a backslash-
               newline pair is not ignored, and the backslash is
               considered to be part of the line.

          rrrreeeeaaaaddddoooonnnnllllyyyy [----ffff] [_n_a_m_e ...]
          rrrreeeeaaaaddddoooonnnnllllyyyy ----pppp
               The given _n_a_m_e_s are marked readonly and the values of
               these _n_a_m_e_s may not be changed by subsequent
               assignment.  If the ----ffff option is supplied, the
               functions corresponding to the _n_a_m_e_s are so marked.  If
               no arguments are given, or if the ----pppp option is
               supplied, a list of all readonly names is printed.  An
               argument of -------- disables option checking for the rest of



     Page 50                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               the arguments.  The return status is 0 unless an
               illegal option is encountered, one of the _n_a_m_e_s is not
               a legal shell variable name, or ----ffff is supplied with a
               _n_a_m_e that is not a function.

          rrrreeeettttuuuurrrrnnnn [_n]
               Causes a function to exit with the return value
               specified by _n.  If _n is omitted, the return status is
               that of the last command executed in the function body.
               If used outside a function, but during execution of a
               script by the .... (ssssoooouuuurrrrcccceeee) command, it causes the shell
               to stop executing that script and return either _n or
               the exit status of the last command executed within the
               script as the exit status of the script.  If used
               outside a function and not during execution of a script
               by ...., the return status is false.

          sssseeeetttt [--------aaaabbbbeeeeffffhhhhkkkkmmmmnnnnppppttttuuuuvvvvxxxxllllddddCCCCHHHHPPPP] [----oooo _o_p_t_i_o_n] [_a_r_g ...]
               ----aaaa      Automatically mark variables which are modified
                       or created for export to the environment of
                       subsequent commands.
               ----bbbb      Cause the status of terminated background jobs
                       to be reported immediately, rather than before
                       the next primary prompt.  (Also see nnnnoooottttiiiiffffyyyy
                       under SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss above).
               ----eeee      Exit immediately if a _s_i_m_p_l_e-_c_o_m_m_a_n_d (see SSSSHHHHEEEELLLLLLLL
                       GGGGRRRRAAAAMMMMMMMMAAAARRRR above) exits with a non-zero status.
                       The shell does not exit if the command that
                       fails is part of an _u_n_t_i_l or _w_h_i_l_e loop, part
                       of an _i_f statement, part of a &&&&&&&& or |||||||| list, or
                       if the command's return value is being inverted
                       via !!!!.
               ----ffff      Disable pathname expansion.
               ----hhhh      Locate and remember function commands as
                       functions are defined.  Function commands are
                       normally looked up when the function is
                       executed.
               ----kkkk      All keyword arguments are placed in the
                       environment for a command, not just those that
                       precede the command name.
               ----mmmm      Monitor mode.  Job control is enabled.  This
                       flag is on by default for interactive shells on
                       systems that support it (see JJJJOOOOBBBB CCCCOOOONNNNTTTTRRRROOOOLLLL
                       above).  Background processes run in a separate
                       process group and a line containing their exit
                       status is printed upon their completion.
               ----nnnn      Read commands but do not execute them.  This
                       may be used to check a shell script for syntax
                       errors.  This is ignored for interactive
                       shells.
               ----oooo _o_p_t_i_o_n-_n_a_m_e
                       The _o_p_t_i_o_n-_n_a_m_e can be one of the following:



     Page 51                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                       aaaalllllllleeeexxxxppppoooorrrrtttt
                               Same as ----aaaa.
                       bbbbrrrraaaacccceeeeeeeexxxxppppaaaannnndddd
                               The shell performs brace expansion (see
                               BBBBrrrraaaacccceeee EEEExxxxppppaaaannnnssssiiiioooonnnn above).  This is on by
                               default.
                       eeeemmmmaaaaccccssss   Use an emacs-style command line editing
                               interface.  This is enabled by default
                               when the shell is interactive, unless
                               the shell is started with the
                               ----nnnnoooolllliiiinnnneeeeeeeeddddiiiittttiiiinnnngggg option.
                       eeeerrrrrrrreeeexxxxiiiitttt Same as ----eeee.
                       hhhhiiiisssstttteeeexxxxppppaaaannnndddd
                               Same as ----HHHH.
                       iiiiggggnnnnoooorrrreeeeeeeeooooffff
                               The effect is as if the shell command
                               `IGNOREEOF=10' had been executed (see
                               SSSShhhheeeellllllll VVVVaaaarrrriiiiaaaabbbblllleeeessss above).
                       iiiinnnntttteeeerrrraaaaccccttttiiiivvvveeee----ccccoooommmmmmmmeeeennnnttttssss
                               Allow a word beginning with #### to cause
                               that word and all remaining characters
                               on that line to be ignored in an
                               interactive shell (see CCCCOOOOMMMMMMMMEEEENNNNTTTTSSSS above).
                       mmmmoooonnnniiiittttoooorrrr Same as ----mmmm.
                       nnnnoooocccclllloooobbbbbbbbeeeerrrr
                               Same as ----CCCC.
                       nnnnooooeeeexxxxeeeecccc  Same as ----nnnn.
                       nnnnoooogggglllloooobbbb  Same as ----ffff.
                       nnnnoooohhhhaaaasssshhhh  Same as ----dddd.
                       nnnnoooottttiiiiffffyyyy  Same as ----bbbb.
                       nnnnoooouuuunnnnsssseeeetttt Same as ----uuuu.
                       pppphhhhyyyyssssiiiiccccaaaallll
                               Same as ----PPPP.
                       ppppoooossssiiiixxxx   Change the behavior of bash where the
                               default operation differs from the
                               Posix 1003.2 standard to match the
                               standard.
                       pppprrrriiiivvvviiiilllleeeeggggeeeedddd
                               Same as ----pppp.
                       vvvveeeerrrrbbbboooosssseeee Same as ----vvvv.
                       vvvviiii      Use a vi-style command line editing
                               interface.
                       xxxxttttrrrraaaacccceeee  Same as ----xxxx.
                       If no _o_p_t_i_o_n-_n_a_m_e is supplied, the values of
                       the current options are printed.
               ----pppp      Turn on _p_r_i_v_i_l_e_g_e_d mode.  In this mode, the
                       $$$$EEEENNNNVVVV file is not processed, and shell functions
                       are not inherited from the environment.  This
                       is enabled automatically on startup if the
                       effective user (group) id is not equal to the
                       real user (group) id.  Turning this option off
                       causes the effective user and group ids to be



     Page 52                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                       set to the real user and group ids.
               ----tttt      Exit after reading and executing one command.
               ----uuuu      Treat unset variables as an error when
                       performing parameter expansion.  If expansion
                       is attempted on an unset variable, the shell
                       prints an error message, and, if not
                       interactive, exits with a non-zero status.
               ----vvvv      Print shell input lines as they are read.
               ----xxxx      After expanding each _s_i_m_p_l_e-_c_o_m_m_a_n_d, bbbbaaaasssshhhh
                       displays the expanded value of PPPPSSSS4444, followed by
                       the command and its expanded arguments.
               ----llll      Save and restore the binding of _n_a_m_e in a ffffoooorrrr
                       _n_a_m_e [in wwwwoooorrrrdddd] command (see SSSSHHHHEEEELLLLLLLL GGGGRRRRAAAAMMMMMMMMAAAARRRR
                       above).
               ----dddd      Disable the hashing of commands that are looked
                       up for execution.  Normally, commands are
                       remembered in a hash table, and once found, do
                       not have to be looked up again.
               ----CCCC      The effect is as if the shell command
                       `noclobber=' had been executed (see SSSShhhheeeellllllll
                       VVVVaaaarrrriiiiaaaabbbblllleeeessss above).
               ----HHHH      Enable !!!! style history substitution.  This flag
                       is on by default when the shell is interactive.
               ----PPPP      If set, do not follow symbolic links when
                       performing commands such as ccccdddd which change the
                       current directory.  The physical directory is
                       used instead.
               --------      If no arguments follow this flag, then the
                       positional parameters are unset.  Otherwise,
                       the positional parameters are set to the _a_r_gs,
                       even if some of them begin with a ----.
               ----       Signal the end of options, cause all remaining
                       _a_r_gs to be assigned to the positional
                       parameters.  The ----xxxx and ----vvvv options are turned
                       off.  If there are no _a_r_gs, the positional
                       parameters remain unchanged.

               The flags are off by default unless otherwise noted.
               Using + rather than - causes these flags to be turned
               off.  The flags can also be specified as options to an
               invocation of the shell.  The current set of flags may
               be found in $$$$----.  After the option arguments are
               processed, the remaining _n _a_r_gs are treated as values
               for the positional parameters and are assigned, in
               order, to $$$$1111, $$$$2222, ............ $$$$_n.  If no options or _a_r_gs are
               supplied, all shell variables are printed.  The return
               status is always true unless an illegal option is
               encountered.

          sssshhhhiiiifffftttt [_n]
               The positional parameters from _n+1 ... are renamed to
               $$$$1111 ................ Parameters represented by the numbers $$$$#### down



     Page 53                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               to $$$$####-_n+1 are unset.  If _n is 0, no parameters are
               changed.  If _n is not given, it is assumed to be 1.  _n
               must be a non-negative number less than or equal to $$$$####.
               If _n is greater than $$$$####, the positional parameters are
               not changed.  The return status is greater than 0 if _n
               is greater than $$$$#### or less than 0; otherwise 0.

          ssssuuuussssppppeeeennnndddd [----ffff]
               Suspend the execution of this shell until it receives a
               SSSSIIIIGGGGCCCCOOOONNNNTTTT signal.  The ----ffff option says not to complain if
               this is a login shell; just suspend anyway.  The return
               status is 0 unless the shell is a login shell and ----ffff is
               not supplied, or if job control is not enabled.

          tttteeeesssstttt _e_x_p_r
          [[[[ _e_x_p_r ]]]]
               Return a status of 0 (true) or 1 (false) depending on
               the evaluation of the conditional expression _e_x_p_r.
               Expressions may be unary or binary.  Unary expressions
               are often used to examine the status of a file.  There
               are string operators and numeric comparison operators
               as well.  Each operator and operand must be a separate
               argument.  If _f_i_l_e is of the form /dev/fd/_n, then file
               descriptor _n is checked.
               ----bbbb _f_i_l_e
                    True if _f_i_l_e exists and is block special.
               ----cccc _f_i_l_e
                    True if _f_i_l_e exists and is character special.
               ----dddd _f_i_l_e
                    True if _f_i_l_e exists and is a directory.
               ----eeee _f_i_l_e
                    True if _f_i_l_e exists.
               ----ffff _f_i_l_e
                    True if _f_i_l_e exists and is a regular file.
               ----gggg _f_i_l_e
                    True if _f_i_l_e exists and is set-group-id.
               ----kkkk _f_i_l_e
                    True if _f_i_l_e has its ``sticky'' bit set.
               ----LLLL _f_i_l_e
                    True if _f_i_l_e exists and is a symbolic link.
               ----pppp _f_i_l_e
                    True if _f_i_l_e exists and is a named pipe.
               ----rrrr _f_i_l_e
                    True if _f_i_l_e exists and is readable.
               ----ssss _f_i_l_e
                    True if _f_i_l_e exists and has a size greater than
                    zero.
               ----SSSS _f_i_l_e
                    True if _f_i_l_e exists and is a socket.
               ----tttt _f_d
                    True if _f_d is opened on a terminal.
               ----uuuu _f_i_l_e



     Page 54                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                    True if _f_i_l_e exists and its set-user-id bit is
                    set.
               ----wwww _f_i_l_e
                    True if _f_i_l_e exists and is writable.
               ----xxxx _f_i_l_e
                    True if _f_i_l_e exists and is executable.
               ----OOOO _f_i_l_e
                    True if _f_i_l_e exists and is owned by the effective
                    user id.
               ----GGGG _f_i_l_e
                    True if _f_i_l_e exists and is owned by the effective
                    group id.
               _f_i_l_e_1 -nnnntttt _f_i_l_e_2
                    True if _f_i_l_e_1 is newer (according to modification
                    date) than _f_i_l_e_2.
               _f_i_l_e_1 -ooootttt _f_i_l_e_2
                    True if _f_i_l_e_1 is older than file2.
               _f_i_l_e_1 ----eeeeffff _f_i_l_e
                    True if _f_i_l_e_1 and _f_i_l_e_2 have the same device and
                    inode numbers.
               ----zzzz _s_t_r_i_n_g
                    True if the length of _s_t_r_i_n_g is zero.
               ----nnnn _s_t_r_i_n_g
               _s_t_r_i_n_g
                    True if the length of _s_t_r_i_n_g is non-zero.
               _s_t_r_i_n_g_1 ==== _s_t_r_i_n_g_2
                    True if the strings are equal.
               _s_t_r_i_n_g_1 !!!!==== _s_t_r_i_n_g_2
                    True if the strings are not equal.
               !!!! _e_x_p_r
                    True if _e_x_p_r is false.
               _e_x_p_r_1 -aaaa _e_x_p_r_2
                    True if both _e_x_p_r_1 AND _e_x_p_r_2 are true.
               _e_x_p_r_1 -oooo _e_x_p_r_2
                    True if either _e_x_p_r_1 OR _e_x_p_r_2 is true.
               _a_r_g_1 OOOOPPPP _a_r_g_2
                    OOOOPPPP is one of ----eeeeqqqq, ----nnnneeee, ----lllltttt, ----lllleeee, ----ggggtttt, or ----ggggeeee.
                    These arithmetic binary operators return true if
                    _a_r_g_1 is equal, not-equal, less-than, less-than-
                    or-equal, greater-than, or greater-than-or-equal
                    than _a_r_g_2, respectively.  _A_r_g_1 and _a_r_g_2 may be
                    positive integers, negative integers, or the
                    special expression ----llll _s_t_r_i_n_g, which evaluates to
                    the length of _s_t_r_i_n_g.

          ttttiiiimmmmeeeessss
               Print the accumulated user and system times for the
               shell and for processes run from the shell.  The return
               status is 0.

          ttttrrrraaaapppp [----llll] [_a_r_g] [_s_i_g_s_p_e_c]
               The command _a_r_g is to be read and executed when the



     Page 55                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               shell receives signal(s) _s_i_g_s_p_e_c.  If _a_r_g is absent or
               ----, all specified signals are reset to their original
               values (the values they had upon entrance to the
               shell).  If _a_r_g is the null string this signal is
               ignored by the shell and by the commands it invokes.
               _s_i_g_s_p_e_c is either a signal name defined in <_s_i_g_n_a_l._h>,
               or a signal number. If _s_i_g_s_p_e_c is EEEEXXXXIIIITTTT (0) the command
               _a_r_g is executed on exit from the shell.  With no
               arguments, ttttrrrraaaapppp prints the list of commands associated
               with each signal number.  The ----llll option causes the
               shell to print a list of signal names and their
               corresponding numbers.  An argument of -------- disables
               option checking for the rest of the arguments.  Signals
               ignored upon entry to the shell cannot be trapped or
               reset.  Trapped signals are reset to their original
               values in a child process when it is created.  The
               return status is false if either the trap name or
               number is invalid; otherwise ttttrrrraaaapppp returns true.

          ttttyyyyppppeeee [----aaaallllllll] [----ttttyyyyppppeeee | ----ppppaaaatttthhhh] _n_a_m_e [_n_a_m_e ...]
               With no options, indicate how each _n_a_m_e would be
               interpreted if used as a command name.  If the ----ttttyyyyppppeeee
               flag is used, ttttyyyyppppeeee prints a phrase which is one of
               _a_l_i_a_s, _k_e_y_w_o_r_d, _f_u_n_c_t_i_o_n, _b_u_i_l_t_i_n, or _f_i_l_e if _n_a_m_e is
               an alias, shell reserved word, function, builtin, or
               disk file, respectively. If the name is not found, then
               nothing is printed, and an exit status of false is
               returned.  If the ----ppppaaaatttthhhh flag is used, ttttyyyyppppeeee either
               returns the name of the disk file that would be
               executed if _n_a_m_e were specified as a command name, or
               nothing if ----ttttyyyyppppeeee would not return _f_i_l_e.  If a command
               is hashed, ----ppppaaaatttthhhh prints the hashed value, not
               necessarily the file that appears first in PPPPAAAATTTTHHHH.  If
               the ----aaaallllllll flag is used, ttttyyyyppppeeee prints all of the places
               that contain an executable named _n_a_m_e.  This includes
               aliases and functions, if and only if the ----ppppaaaatttthhhh flag is
               not also used.  The table of hashed commands is not
               consulted when using ----aaaallllllll.  ttttyyyyppppeeee accepts ----aaaa, ----tttt, and ----pppp
               in place of ----aaaallllllll, ----ttttyyyyppppeeee, and ----ppppaaaatttthhhh, respectively.  An
               argument of -------- disables option checking for the rest of
               the arguments.  ttttyyyyppppeeee returns true if any of the
               arguments are found, false if none are found.

          uuuulllliiiimmmmiiiitttt [----SSSSHHHHaaaaccccddddffffmmmmssssttttppppnnnnuuuuvvvv [_l_i_m_i_t]]
               UUUUlllliiiimmmmiiiitttt provides control over the resources available to
               the shell and to processes started by it, on systems
               that allow such control.  The value of _l_i_m_i_t can be a
               number in the unit specified for the resource, or the
               value uuuunnnnlllliiiimmmmiiiitttteeeedddd.  The HHHH and SSSS options specify that the
               hard or soft limit is set for the given resource.  A
               hard limit cannot be increased once it is set; a soft
               limit may be increased up to the value of the hard



     Page 56                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               limit.  If neither HHHH nor SSSS is specified, the command
               applies to the soft limit.  If _l_i_m_i_t is omitted, the
               current value of the soft limit of the resource is
               printed, unless the HHHH option is given.  When more than
               one resource is specified, the limit name and unit is
               printed before the value.  Other options are
               interpreted as follows:
               ----aaaa   all current limits are reported
               ----cccc   the maximum size of core files created
               ----dddd   the maximum size of a process's data segment
               ----ffff   the maximum size of files created by the shell
               ----mmmm   the maximum resident set size
               ----ssss   the maximum stack size
               ----tttt   the maximum amount of cpu time in seconds
               ----pppp   the pipe size in 512-byte blocks (this may not be
                    set)
               ----nnnn   the maximum number of open file descriptors (most
                    systems do not allow this value to be set, only
                    displayed)
               ----uuuu   the maximum number of processes available to a
                    single user
               ----vvvv   The maximum amount of virtual memory available to
                    the shell

               An argument of -------- disables option checking for the rest
               of the arguments.  If _l_i_m_i_t is given, it is the new
               value of the specified resource (the ----aaaa option is
               display only).  If no option is given, then ----ffff is
               assumed.  Values are in 1024-byte increments, except
               for ----tttt, which is in seconds, ----pppp, which is in units of
               512-byte blocks, and ----nnnn and ----uuuu, which are unscaled
               values.  The return status is 0 unless an illegal
               option is encountered, a non-numeric argument other
               than uuuunnnnlllliiiimmmmiiiitttteeeedddd is supplied as _l_i_m_i_t, or an error occurs
               while setting a new limit.

          uuuummmmaaaasssskkkk [----SSSS] [_m_o_d_e]
               The user file-creation mask is set to _m_o_d_e.  If _m_o_d_e
               begins with a digit, it is interpreted as an octal
               number; otherwise it is interpreted as a symbolic mode
               mask similar to that accepted by _c_h_m_o_d(1).  If _m_o_d_e is
               omitted, or if the ----SSSS option is supplied, the current
               value of the mask is printed.  The ----SSSS option causes the
               mask to be printed in symbolic form; the default output
               is an octal number.  An argument of -------- disables option
               checking for the rest of the arguments.  The return
               status is 0 if the mode was successfully changed or if
               no _m_o_d_e argument was supplied, and false otherwise.

          uuuunnnnaaaalllliiiiaaaassss [-aaaa] [_n_a_m_e ...]
               Remove _n_a_m_es from the list of defined aliases.  If ----aaaa
               is supplied, all alias definitions are removed.  The



     Page 57                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



               return value is true unless a supplied _n_a_m_e is not a
               defined alias.

          uuuunnnnsssseeeetttt [-ffffvvvv] [_n_a_m_e ...]
               For each _n_a_m_e, remove the corresponding variable or,
               given the ----ffff option, function.  An argument of --------
               disables option checking for the rest of the arguments.
               Note that PPPPAAAATTTTHHHH, IIIIFFFFSSSS, PPPPPPPPIIIIDDDD, PPPPSSSS1111, PPPPSSSS2222, UUUUIIIIDDDD, and EEEEUUUUIIIIDDDD
               cannot be unset.  If any of RRRRAAAANNNNDDDDOOOOMMMM, SSSSEEEECCCCOOOONNNNDDDDSSSS, LLLLIIIINNNNEEEENNNNOOOO, or
               HHHHIIIISSSSTTTTCCCCMMMMDDDD are unset, they lose their special properties,
               even if they are subsequently reset.  The exit status
               is true unless a _n_a_m_e does not exist or is non-
               unsettable.

          wwwwaaaaiiiitttt [_n]
               Wait for the specified process and return its
               termination status.  _n may be a process ID or a job
               specification; if a job spec is given, all processes in
               that job's pipeline are waited for.  If _n is not given,
               all currently active child processes are waited for,
               and the return status is zero.  If _n specifies a non-
               existant process or job, the return status is 127.
               Otherwise, the return status is the exit status of the
               last process or job waited for.

     IIIINNNNVVVVOOOOCCCCAAAATTTTIIIIOOOONNNN
          A _l_o_g_i_n _s_h_e_l_l is one whose first character of argument zero
          is a ----, or one started with the ----llllooooggggiiiinnnn flag.

          An _i_n_t_e_r_a_c_t_i_v_e shell is one whose standard input and output
          are both connected to terminals (as determined by
          _i_s_a_t_t_y(3)), or one started with the ----iiii option.  PPPPSSSS1111 is set
          and $$$$---- includes iiii if bbbbaaaasssshhhh is interactive, allowing a shell
          script or a startup file to test this state.

          Login shells:
            On login (subject to the ----nnnnoooopppprrrrooooffffiiiilllleeee option):
                  if /_e_t_c/_p_r_o_f_i_l_e exists, source it.

                  if ~/._b_a_s_h__p_r_o_f_i_l_e exists, source it,
                    else if ~/._b_a_s_h__l_o_g_i_n exists, source it,
                      else if ~/._p_r_o_f_i_l_e exists, source it.

            On exit:
                  if ~/._b_a_s_h__l_o_g_o_u_t exists, source it.

          Non-login interactive shells:
            On startup (subject to the ----nnnnoooorrrrcccc and ----rrrrccccffffiiiilllleeee options):
                  if ~/._b_a_s_h_r_c exists, source it.

          Non-interactive shells:
            On startup:



     Page 58                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



                  if the environment variable EEEENNNNVVVV is non-null, expand
                  it and source the file it names, as if the command
                          if [ "$ENV" ]; then . $ENV; fi
                  had been executed, but do not use PPPPAAAATTTTHHHH to search
                  for the pathname.  When not started in Posix mode, bash
                  looks for BBBBAAAASSSSHHHH____EEEENNNNVVVV before EEEENNNNVVVV.

          If Bash is invoked as sssshhhh, it tries to mimic the behavior of
          sssshhhh as closely as possible.  For a login shell, it attempts
          to source only /_e_t_c/_p_r_o_f_i_l_e and ~/._p_r_o_f_i_l_e, in that order.
          The ----nnnnoooopppprrrrooooffffiiiilllleeee option may still be used to disable this
          behavior.  A shell invoked as sssshhhh does not attempt to source
          any other startup files.

          When bbbbaaaasssshhhh is started in _p_o_s_i_x mode, as with the ----ppppoooossssiiiixxxx
          command line option, it follows the Posix standard for
          startup files.  In this mode, the EEEENNNNVVVV variable is expanded
          and that file sourced; no other startup files are read.

     SSSSEEEEEEEE AAAALLLLSSSSOOOO
          _B_a_s_h _F_e_a_t_u_r_e_s, Brian Fox and Chet Ramey
          _T_h_e _G_n_u _R_e_a_d_l_i_n_e _L_i_b_r_a_r_y, Brian Fox and Chet Ramey
          _T_h_e _G_n_u _H_i_s_t_o_r_y _L_i_b_r_a_r_y, Brian Fox and Chet Ramey
     Lennert
          _A _S_y_s_t_e_m _V _C_o_m_p_a_t_i_b_l_e _I_m_p_l_e_m_e_n_t_a_t_i_o_n _o_f _4._2_B_S_D _J_o_b _C_o_n_t_r_o_l, David
     _U_t_i_l_i_t_i_e_s, IEEE
          _P_o_r_t_a_b_l_e _O_p_e_r_a_t_i_n_g _S_y_s_t_e_m _I_n_t_e_r_f_a_c_e (_P_O_S_I_X) _P_a_r_t _2: _S_h_e_l_l _a_n_d
          _s_h(1), _k_s_h(1), _c_s_h(1)
          _e_m_a_c_s(1), _v_i(1)
          _r_e_a_d_l_i_n_e(3)

     FFFFIIIILLLLEEEESSSS
          /_b_i_n/_b_a_s_h
               The bbbbaaaasssshhhh executable
          /_e_t_c/_p_r_o_f_i_l_e
               The systemwide initialization file, executed for login
               shells
          ~/._b_a_s_h__p_r_o_f_i_l_e
               The personal initialization file, executed for login
               shells
          ~/._b_a_s_h_r_c
               The individual per-interactive-shell startup file
          ~/._i_n_p_u_t_r_c
               Individual _r_e_a_d_l_i_n_e initialization file

     AAAAUUUUTTTTHHHHOOOORRRRSSSS
               Brian Fox, Free Software Foundation (primary author)
               [e-mail]

               Chet Ramey, Case Western Reserve University
               [e-mail]




     Page 59                                          (printed 7/6/95)






     BBBBAAAASSSSHHHH((((1111))))                 GGGGNNNNUUUU ((((1111999999995555 MMMMaaaarrrr 9999))))                  BBBBAAAASSSSHHHH((((1111))))



     BBBBUUUUGGGG RRRREEEEPPPPOOOORRRRTTTTSSSS
          If you find a bug in bbbbaaaasssshhhh,,,, you should report it.  But first,
          you should make sure that it really is a bug, and that it
          appears in the latest version of bbbbaaaasssshhhh that you have.

          Once you have determined that a bug actually exists, mail a
          bug report to _b_a_s_h-_m_a_i_n_t_a_i_n_e_r_s@_p_r_e_p._a_i._M_I_T._E_d_u.  If you have
          a fix, you are welcome to mail that as well!  Suggestions
          and `philosophical' bug reports may be mailed to _b_u_g-
          _b_a_s_h@_p_r_e_p._a_i._M_I_T._E_d_u or posted to the Usenet newsgroup
          ggggnnnnuuuu....bbbbaaaasssshhhh....bbbbuuuugggg.

          ALL bug reports should include:

          The version number of bbbbaaaasssshhhh
          The hardware and operating system
          The compiler used to compile
          A description of the bug behaviour
          A short script or `recipe' which exercises the bug

          Comments and bug reports concerning this manual page should
          be directed to _c_h_e_t@_i_n_s._C_W_R_U._E_d_u.

     BBBBUUUUGGGGSSSS
          It's too big and too slow.

          There are some subtle differences between bbbbaaaasssshhhh and
          traditional versions of sssshhhh, mostly because of the PPPPOOOOSSSSIIIIXXXX
          specification.

          Aliases are confusing in some uses.
























     Page 60                                          (printed 7/6/95)